@datagrok/eda 1.4.3 → 1.4.4

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 (152) hide show
  1. package/CHANGELOG.md +4 -0
  2. package/dist/_d4c0.js +279 -0
  3. package/dist/_d4c0.js.map +1 -0
  4. package/dist/node_modules_datagrok-libraries_math_src_dbscan_wasm_clustering-worker_js.js +279 -0
  5. package/dist/node_modules_datagrok-libraries_math_src_dbscan_wasm_clustering-worker_js.js.map +1 -0
  6. package/dist/node_modules_datagrok-libraries_ml_src_MCL_mcl-sparse-matrix-mult-worker_js.js +59 -0
  7. package/dist/node_modules_datagrok-libraries_ml_src_MCL_mcl-sparse-matrix-mult-worker_js.js.map +1 -0
  8. package/dist/node_modules_datagrok-libraries_ml_src_distance-matrix_distance-matrix-worker_js.js +284 -0
  9. package/dist/node_modules_datagrok-libraries_ml_src_distance-matrix_distance-matrix-worker_js.js.map +1 -0
  10. package/dist/node_modules_datagrok-libraries_ml_src_distance-matrix_single-value-knn-worker_js.js +265 -0
  11. package/dist/node_modules_datagrok-libraries_ml_src_distance-matrix_single-value-knn-worker_js.js.map +1 -0
  12. package/dist/node_modules_datagrok-libraries_ml_src_distance-matrix_sparse-matrix-worker_js.js +287 -0
  13. package/dist/node_modules_datagrok-libraries_ml_src_distance-matrix_sparse-matrix-worker_js.js.map +1 -0
  14. package/dist/package-test.js +26140 -1
  15. package/dist/package-test.js.map +1 -1
  16. package/dist/package.js +30337 -1
  17. package/dist/package.js.map +1 -1
  18. package/dist/src_workers_softmax-worker_ts.js +154 -0
  19. package/dist/src_workers_softmax-worker_ts.js.map +1 -0
  20. package/dist/src_workers_tsne-worker_ts.js +244 -0
  21. package/dist/src_workers_tsne-worker_ts.js.map +1 -0
  22. package/dist/src_workers_umap-worker_ts.js +252 -0
  23. package/dist/src_workers_umap-worker_ts.js.map +1 -0
  24. package/dist/vendors-node_modules_datagrok-libraries_math_src_dbscan_wasm_dbscan_js.js +1253 -0
  25. package/dist/vendors-node_modules_datagrok-libraries_math_src_dbscan_wasm_dbscan_js.js.map +1 -0
  26. package/dist/vendors-node_modules_datagrok-libraries_math_src_hierarchical-clustering_wasm_clustering-worker_js.js +942 -0
  27. package/dist/vendors-node_modules_datagrok-libraries_math_src_hierarchical-clustering_wasm_clustering-worker_js.js.map +1 -0
  28. package/dist/vendors-node_modules_datagrok-libraries_math_src_webGPU_sparse-matrix_webGPU-sparse-matrix_js-07693f.js +1525 -0
  29. package/dist/vendors-node_modules_datagrok-libraries_math_src_webGPU_sparse-matrix_webGPU-sparse-matrix_js-07693f.js.map +1 -0
  30. package/dist/vendors-node_modules_datagrok-libraries_ml_src_MCL_mcl-worker_js-node_modules_datagrok-librar-e4203d.js +2244 -0
  31. package/dist/vendors-node_modules_datagrok-libraries_ml_src_MCL_mcl-worker_js-node_modules_datagrok-librar-e4203d.js.map +1 -0
  32. package/dist/vendors-node_modules_datagrok-libraries_ml_src_distance-matrix_knn-threshold-worker_js.js +286 -0
  33. package/dist/vendors-node_modules_datagrok-libraries_ml_src_distance-matrix_knn-threshold-worker_js.js.map +1 -0
  34. package/dist/vendors-node_modules_datagrok-libraries_ml_src_distance-matrix_knn-worker_js.js +280 -0
  35. package/dist/vendors-node_modules_datagrok-libraries_ml_src_distance-matrix_knn-worker_js.js.map +1 -0
  36. package/dist/vendors-node_modules_datagrok-libraries_ml_src_distance-matrix_sparse-matrix-threshold-worker_js.js +282 -0
  37. package/dist/vendors-node_modules_datagrok-libraries_ml_src_distance-matrix_sparse-matrix-threshold-worker_js.js.map +1 -0
  38. package/dist/vendors-node_modules_datagrok-libraries_ml_src_distance-matrix_utils_js-node_modules_datagrok-72c7b2.js +1821 -0
  39. package/dist/vendors-node_modules_datagrok-libraries_ml_src_distance-matrix_utils_js-node_modules_datagrok-72c7b2.js.map +1 -0
  40. package/dist/vendors-node_modules_datagrok-libraries_ml_src_multi-column-dimensionality-reduction_mulit-co-3800a0.js +7776 -0
  41. package/dist/vendors-node_modules_datagrok-libraries_ml_src_multi-column-dimensionality-reduction_mulit-co-3800a0.js.map +1 -0
  42. package/dist/vendors-node_modules_keckelt_tsne_lib_index_js.js +379 -0
  43. package/dist/vendors-node_modules_keckelt_tsne_lib_index_js.js.map +1 -0
  44. package/dist/vendors-node_modules_ml-matrix_matrix_mjs.js +5946 -0
  45. package/dist/vendors-node_modules_ml-matrix_matrix_mjs.js.map +1 -0
  46. package/dist/vendors-node_modules_umap-js_dist_index_js.js +2284 -0
  47. package/dist/vendors-node_modules_umap-js_dist_index_js.js.map +1 -0
  48. package/dist/wasm_EDAForWebWorker_js-wasm_callWasmForWebWorker_js.js +779 -0
  49. package/dist/wasm_EDAForWebWorker_js-wasm_callWasmForWebWorker_js.js.map +1 -0
  50. package/dist/wasm_workers_errorWorker_js.js +267 -0
  51. package/dist/wasm_workers_errorWorker_js.js.map +1 -0
  52. package/dist/wasm_workers_fitLinearRegressionParamsWithDataNormalizingWorker_js.js +267 -0
  53. package/dist/wasm_workers_fitLinearRegressionParamsWithDataNormalizingWorker_js.js.map +1 -0
  54. package/dist/wasm_workers_fitLinearRegressionParamsWorker_js.js +267 -0
  55. package/dist/wasm_workers_fitLinearRegressionParamsWorker_js.js.map +1 -0
  56. package/dist/wasm_workers_fitSoftmaxWorker_js.js +267 -0
  57. package/dist/wasm_workers_fitSoftmaxWorker_js.js.map +1 -0
  58. package/dist/wasm_workers_generateDatasetWorker_js.js +267 -0
  59. package/dist/wasm_workers_generateDatasetWorker_js.js.map +1 -0
  60. package/dist/wasm_workers_normalizeDatasetWorker_js.js +267 -0
  61. package/dist/wasm_workers_normalizeDatasetWorker_js.js.map +1 -0
  62. package/dist/wasm_workers_partialLeastSquareRegressionWorker_js.js +267 -0
  63. package/dist/wasm_workers_partialLeastSquareRegressionWorker_js.js.map +1 -0
  64. package/dist/wasm_workers_predictByLSSVMWorker_js.js +267 -0
  65. package/dist/wasm_workers_predictByLSSVMWorker_js.js.map +1 -0
  66. package/dist/wasm_workers_principalComponentAnalysisNipalsWorker_js.js +267 -0
  67. package/dist/wasm_workers_principalComponentAnalysisNipalsWorker_js.js.map +1 -0
  68. package/dist/wasm_workers_principalComponentAnalysisWorkerUpd_js.js +271 -0
  69. package/dist/wasm_workers_principalComponentAnalysisWorkerUpd_js.js.map +1 -0
  70. package/dist/wasm_workers_trainAndAnalyzeLSSVMWorker_js.js +267 -0
  71. package/dist/wasm_workers_trainAndAnalyzeLSSVMWorker_js.js.map +1 -0
  72. package/dist/wasm_workers_trainLSSVMWorker_js.js +267 -0
  73. package/dist/wasm_workers_trainLSSVMWorker_js.js.map +1 -0
  74. package/dist/wasm_workers_xgboostWorker_js.js +279 -0
  75. package/dist/wasm_workers_xgboostWorker_js.js.map +1 -0
  76. package/package.json +5 -4
  77. package/src/package-api.ts +259 -0
  78. package/src/package.g.ts +522 -0
  79. package/src/package.ts +907 -678
  80. package/test-console-output-1.log +78 -93
  81. package/test-record-1.mp4 +0 -0
  82. package/tsconfig.json +2 -2
  83. package/webpack.config.js +5 -0
  84. package/dist/111.js +0 -2
  85. package/dist/111.js.map +0 -1
  86. package/dist/128.js +0 -2
  87. package/dist/128.js.map +0 -1
  88. package/dist/153.js +0 -2
  89. package/dist/153.js.map +0 -1
  90. package/dist/23.js +0 -2
  91. package/dist/23.js.map +0 -1
  92. package/dist/234.js +0 -2
  93. package/dist/234.js.map +0 -1
  94. package/dist/242.js +0 -2
  95. package/dist/242.js.map +0 -1
  96. package/dist/260.js +0 -2
  97. package/dist/260.js.map +0 -1
  98. package/dist/33.js +0 -2
  99. package/dist/33.js.map +0 -1
  100. package/dist/348.js +0 -2
  101. package/dist/348.js.map +0 -1
  102. package/dist/377.js +0 -2
  103. package/dist/377.js.map +0 -1
  104. package/dist/412.js +0 -2
  105. package/dist/412.js.map +0 -1
  106. package/dist/415.js +0 -2
  107. package/dist/415.js.map +0 -1
  108. package/dist/501.js +0 -2
  109. package/dist/501.js.map +0 -1
  110. package/dist/531.js +0 -2
  111. package/dist/531.js.map +0 -1
  112. package/dist/583.js +0 -2
  113. package/dist/583.js.map +0 -1
  114. package/dist/589.js +0 -2
  115. package/dist/589.js.map +0 -1
  116. package/dist/603.js +0 -2
  117. package/dist/603.js.map +0 -1
  118. package/dist/656.js +0 -2
  119. package/dist/656.js.map +0 -1
  120. package/dist/682.js +0 -2
  121. package/dist/682.js.map +0 -1
  122. package/dist/705.js +0 -2
  123. package/dist/705.js.map +0 -1
  124. package/dist/727.js +0 -2
  125. package/dist/727.js.map +0 -1
  126. package/dist/731.js +0 -2
  127. package/dist/731.js.map +0 -1
  128. package/dist/738.js +0 -3
  129. package/dist/738.js.LICENSE.txt +0 -51
  130. package/dist/738.js.map +0 -1
  131. package/dist/763.js +0 -2
  132. package/dist/763.js.map +0 -1
  133. package/dist/778.js +0 -2
  134. package/dist/778.js.map +0 -1
  135. package/dist/783.js +0 -2
  136. package/dist/783.js.map +0 -1
  137. package/dist/793.js +0 -2
  138. package/dist/793.js.map +0 -1
  139. package/dist/801.js +0 -2
  140. package/dist/801.js.map +0 -1
  141. package/dist/810.js +0 -2
  142. package/dist/810.js.map +0 -1
  143. package/dist/860.js +0 -2
  144. package/dist/860.js.map +0 -1
  145. package/dist/907.js +0 -2
  146. package/dist/907.js.map +0 -1
  147. package/dist/950.js +0 -2
  148. package/dist/950.js.map +0 -1
  149. package/dist/980.js +0 -2
  150. package/dist/980.js.map +0 -1
  151. package/dist/990.js +0 -2
  152. package/dist/990.js.map +0 -1
package/dist/vendors-node_modules_datagrok-libraries_math_src_webGPU_sparse-matrix_webGPU-sparse-matrix_js-07693f.js.map ADDED
@@ -0,0 +1 @@
1
+ {"version":3,"file":"vendors-node_modules_datagrok-libraries_math_src_webGPU_sparse-matrix_webGPU-sparse-matrix_js-07693f.js","mappings":";;;;;;;;;;;;;;AAAA,iBAAiB,SAAI,IAAI,SAAI;AAC7B,4BAA4B,+DAA+D,iBAAiB;AAC5G;AACA,oCAAoC,MAAM,+BAA+B,YAAY;AACrF,mCAAmC,MAAM,mCAAmC,YAAY;AACxF,gCAAgC;AAChC;AACA,KAAK;AACL;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8DAA8D,qCAAqC;AACnG;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb,yDAAyD;AACzD;AACA;AACA,mDAAmD;AACnD;AACA;AACA;AACA;AACA,6DAA6D;AAC7D;AACA;AACA,uBAAuB;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,wC;;;;;;;;;;;;;;;AChFA;AACA;AACA;AACA,yBAAyB,MAAM,YAAY;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,MAAM,YAAY;AAC3C;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA,CAAC,8CAA8C;AACxC;AACP;AACA;AACA;AACA,8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oEAAoE;AAC7D;AACP;AACA,8CAA8C,WAAW;AACzD,8CAA8C,WAAW;AACzD;AACA;AACA;AACA;AACA;;AAEA;AACA,mBAAmB,MAAM,gBAAgB;AACzC;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACO;AACP,2FAA2F,WAAW;AACtG;AACA;AACA,8CAA8C,WAAW;AACzD,8CAA8C,WAAW;AACzD;AACA;AACA;AACA;AACA;;AAEA,+CAA+C,WAAW,GAAG;AAC7D;AACA,mBAAmB,MAAM,gBAAgB;AACzC;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACO;AACP;AACA,8CAA8C,WAAW;AACzD,8CAA8C,WAAW;AACzD;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,yCAAyC,iBAAiB,QAAQ;AAClE;AACA;AACA,yBAAyB;;AAEzB;AACA,mBAAmB,cAAc;AACjC;AACA;;AAEA;AACA,mBAAmB,cAAc;AACjC;AACA;AACA;AACA;AACA;AACA,uBAAuB,cAAc;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACO;AACP;AACA,2FAA2F,WAAW;AACtG;AACA;AACA;AACA,kDAAkD,WAAW;AAC7D,kDAAkD,WAAW;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C,iBAAiB,QAAQ;AACtE;AACA;AACA;AACA,qCAAqC,iBAAiB;AACtD,uCAAuC,iBAAiB;;AAExD,yDAAyD;AACzD,mEAAmE;AACnE;AACA,6BAA6B;AAC7B;AACA,uBAAuB,cAAc;AACrC,iGAAiG;AACjG;AACA;AACA;;AAEA,kDAAkD,aAAa;AAC/D;AACA,uBAAuB,cAAc;AACrC;AACA;AACA;AACA;AACA;AACA,2BAA2B,cAAc;AACzC;AACA;AACA;AACA,uCAAuC;AACvC;AACA;AACA,gBAAgB;AAChB;AACA;AACA,2CAA2C;AAC3C;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACO;AACP;AACA;AACA,mBAAmB,MAAM,eAAe;AACxC;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA,mBAAmB,MAAM,eAAe;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA,mBAAmB,MAAM,eAAe;AACxC;AACA;AACA;AACA;AACA;AACO;AACP;AACA,8CAA8C,WAAW;AACzD,8CAA8C,WAAW;AACzD;AACA;AACA;AACA,mBAAmB,aAAa;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP,6BAA6B,YAAY;AACzC;AACA,gCAAgC;AAChC;AACA;AACA;AACA,mDAAmD;AAC5C;AACP;AACA;AACA;AACA,mBAAmB,MAAM,aAAa,GAAG;AACzC;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,mBAAmB,MAAM,aAAa,GAAG;AACzC;AACA;;AAEA;AACA;AACA;AACO;AACP;AACA;AACA;AACA,mBAAmB,MAAM,aAAa,GAAG;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,MAAM,aAAa,GAAG;AACzC;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA,mBAAmB,MAAM,aAAa,GAAG;AACzC;AACA;AACA;AACA,iCAAiC;AACjC;AACA;AACA;AACA;AACA,mBAAmB,MAAM,aAAa,GAAG;AACzC;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA,mBAAmB,MAAM,aAAa,GAAG;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,MAAM,aAAa,GAAG;AACzC;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,wCAAwC;AAClC;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qD;;;;;;;;;;;;;;;AC7YA;AACsI;AAC/H,uDAAuD,0FAAc;AAC5E,YAAY,+CAA+C;AAC3D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,kGAAsB,gBAAgB,kGAAsB;AACrE,4CAA4C,eAAe,kCAAkC,UAAU;AACvG;AACA;AACA,uBAAuB,sGAA0B;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,iCAAiC;AACjC;AACA;AACA;AACA,2BAA2B,0FAAc,wCAAwC,0FAAc;AAC/F;AACA;AACA;AACA;AACA,4BAA4B,4BAA4B;AACxD;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,kCAAkC;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,yBAAyB;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,uCAAuC;AAC/D;AACA;AACA;AACA;AACA,4BAA4B,WAAW;AACvC,iCAAiC,WAAW;AAC5C,8BAA8B,WAAW,qBAAqB,oBAAoB,KAAK,oBAAoB;AAC3G;AACA,gCAAgC,0FAAc;AAC9C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC;AACjC;AACA;AACA;AACA;AACA,mBAAmB,WAAW;AAC9B;AACA;AACA,kCAAkC,WAAW,gBAAgB,aAAa,IAAI,YAAY,KAAK,mBAAmB;AAClH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+C;;;;;;;;;;;;;;;;;;AC5IA,iBAAiB,SAAI,IAAI,SAAI;AAC7B,4BAA4B,+DAA+D,iBAAiB;AAC5G;AACA,oCAAoC,MAAM,+BAA+B,YAAY;AACrF,mCAAmC,MAAM,mCAAmC,YAAY;AACxF,gCAAgC;AAChC;AACA,KAAK;AACL;AAC2G;AACP;AAC3B;AAC1B;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yDAAyD,4BAA4B;AACrF,oCAAoC,eAAe;AACnD;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,2DAAY;AACzC;AACA,yBAAyB;AACzB,uDAAuD,0FAAc;AACrE;AACA;AACA,4DAA4D,sFAAiB;AAC7E;AACA;AACA,2CAA2C;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+CAA+C;AAC/C,8CAA8C;AAC9C;AACA,mBAAmB,qFAAiB;AACpC,SAAS;AACT;AACA;AACA;AACA;AACA,kCAAkC,sFAAiB,YAAY;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,GAAG;AACZ;AACA;AACA;AACA;AACA,+CAA+C;AAC/C,sFAAsF;AACtF,6EAA6E;AAC7E,sCAAsC;AACtC;AACA,mGAAmG;AACnG,uEAAuE;AACvE,2EAA2E;AAC3E,4FAA4F;AAC5F;AACA;AACA;AACA,kCAAkC,2BAA2B,oCAAoC,2BAA2B;AAC5H,oDAAoD,sBAAsB;AAC1E,iGAAiG,0BAA0B;AAC3H;AACA;AACA,4BAA4B,0BAA0B,KAAK,aAAa;AACxE,4BAA4B,0BAA0B,KAAK,aAAa;AACxE,oCAAoC,0BAA0B,KAAK,aAAa;AAChF,0BAA0B,aAAa;AACvC,yBAAyB,aAAa;AACtC;AACA;AACA;AACA;AACA,gCAAgC,aAAa;AAC7C,gCAAgC,aAAa;AAC7C,8BAA8B,aAAa;AAC3C,8BAA8B,aAAa;;AAE3C;AACA,qCAAqC,SAAS,KAAK,aAAa;AAChE;AACA,4BAA4B,aAAa;AACzC;AACA,QAAQ,UAAU;AAClB;AACA;AACA;;AAEA;AACA;AACA;AACA,QAAQ;AACR;;AAEA;AACA;AACA;AACA,+BAA+B,kBAAkB,IAAI,kBAAkB;AACvE;AACA;AACA,QAAQ,kDAAkD,QAAQ;AAClE;AACA;AACA,sCAAsC,qBAAqB;AAC3D,2BAA2B,aAAa;AACxC,gBAAgB;AAChB;AACA;AACA;AACA,oEAAoE,SAAS;AAC7E,oEAAoE,SAAS;AAC7E;AACA;AACA;AACA,sCAAsC;AACtC;AACA;AACA,gBAAgB;AAChB;AACA,sBAAsB,MAAM,yBAAyB;AACrD;AACA;AACA;AACA;AACA,uBAAuB,0BAA0B;AACjD;AACA;AACA;AACA,sBAAsB,YAAY;AAClC;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,SAAS;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,MAAM;;;AAGN;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,kFAAkF;AAClF;AACA;AACA;AACA,wBAAwB,kBAAkB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mGAAmG;AACnG;AACA;AACA;AACA;AACA,sDAAsD;AACtD;AACA,2DAA2D;AAC3D;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,iFAAiF;AACjF;AACA;AACA;AACA;AACA;AACA,2EAA2E;AAC3E;AACA;AACA,2EAA2E;AAC3E;AACA;AACA,2EAA2E;AAC3E;AACA;AACA,2EAA2E;AAC3E;AACA;AACA;AACA,gFAAgF;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+GAA+G;AAC/G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2DAA2D;AAC3D;AACA,gEAAgE;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,2EAA2E;AAC3E;AACA;AACA;AACA;AACA,kIAAkI;AAClI;AACA,kEAAkE;AAClE;AACA;AACA;AACA,gFAAgF;AAChF;AACA;AACA;AACA;AACA;AACA;AACA,yDAAyD;AACzD;AACA,8DAA8D;AAC9D;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,wBAAwB,6BAA6B;AACvE,kBAAkB,wBAAwB,0BAA0B;AACpE,kBAAkB,wBAAwB,yBAAyB;AACnE;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B,4BAA4B;AAC3D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,qBAAqB;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB,KAAK;AACL;AACA;AACA;AACA;AACA,2BAA2B,EAAE;AAC7B,oCAAoC,EAAE;AACtC,oCAAoC,EAAE;AACtC,mCAAmC;AACnC,YAAY,2FAAe;AAC3B;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,oCAAoC,uBAAuB;AAC3D,UAAU,2CAA2C,EAAE,oBAAoB,EAAE,iBAAiB;AAC9F,UAAU,+FAA0B;AACpC;AACA;AACA;AACA;AACA;AACA,gD;;;;;;;;;;;;;;;;AC5bqD;AACN;AACxC;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,SAAS;AACjC;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,UAAU;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,SAAS;AACjC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA,gEAAgE,sCAAsC,8DAA0B;AAChI;AACA;AACA;AACA;AACA;AACA,2CAA2C,aAAa;AACxD;AACA;AACA;AACA;AACA;AACA,qDAAqD,0KAAyC;AAC9F,0BAA0B,yBAAyB;AACnD;AACA;AACA;AACA;AACA,oCAAoC,gFAAgF;AACpH,2CAA2C,gFAAgF;AAC3H,4CAA4C,QAAQ,yBAAyB;AAC7E;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,qBAAqB;AAC7D;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA,mDAAmD;AACnD;AACA;AACA;AACA,4DAA4D;AAC5D;AACA;AACA,oEAAoE;AACpE;AACA;AACA,uGAAuG,8DAA0B;AACjI;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD,kLAAyC;AAC9F,0BAA0B,yBAAyB;AACnD;AACA;AACA;AACA;AACA,oCAAoC,sDAAsD;AAC1F,2CAA2C,gFAAgF;AAC3H,4CAA4C,QAAQ,mCAAmC;AACvF;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,0BAA0B;AAClE;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA,4BAA4B,sBAAsB;AAClD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,sBAAsB;AAClD,gCAAgC,wCAAwC;AACxE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qHAAqH,8DAA0B;AAC/I;AACA;AACA;AACA;AACA;AACA,qDAAqD,6KAA4C;AACjG;AACA;AACA;AACA;AACA,0BAA0B,yBAAyB;AACnD;AACA;AACA;AACA;AACA,oCAAoC,sDAAsD;AAC1F,2CAA2C,gIAAgI;AAC3K,4CAA4C,QAAQ,mCAAmC;AACvF;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,0BAA0B;AAClE;AACA;AACA,aAAa;AACb;AACA;AACA,iCAAiC;AACjC;AACA,4BAA4B,qCAAqC;AACjE,gBAAgB,qDAAa;AAC7B;AACA;AACA;AACA,+FAA+F,8DAA0B;AACzH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD,wKAA+B;AACpF,0BAA0B,yBAAyB;AACnD;AACA;AACA;AACA;AACA,oCAAoC,sDAAsD;AAC1F,2CAA2C,kFAAkF;AAC7H,4CAA4C,QAAQ,mCAAmC;AACvF;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,0BAA0B;AAClE;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,sBAAsB;AAClD,gCAAgC,wCAAwC;AACxE,oBAAoB,qDAAa;AACjC;AACA;AACA;AACA;AACA,sFAAsF,8DAA0B;AAChH;AACA,0CAA0C,4LAAmD;AAC7F;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,yBAAyB;AACvD;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB,yDAAyD,QAAQ,mBAAmB;AACpF;AACA;AACA;AACA;AACA,4CAA4C,UAAU;AACtD;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uFAAuF,8DAA0B;AACjH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,6CAAK,iBAAiB,6CAAK;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA,2CAA2C,+y8C","sources":["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/preprocessing/webGPU-process-info.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/sparse-matrix/webGPU-sparse-matrix.js","webpack://eda/./node_modules/@datagrok-libraries/ml/src/distance-matrix/sparse-matrix-service.js"],"sourcesContent":["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 webGPUVectorCosine(maxArraySize, _entryIndex) {\n return `\n var dist: f32 = 0.0;\n var productSum: f32 = 0.0;\n var aSquareSum: f32 = 0.0;\n var bSquareSum: f32 = 0.0;\n for (var i = 0u; i < ${maxArraySize}; i = i + 1u) {\n productSum = productSum + f32(a[i] * b[i]);\n aSquareSum = aSquareSum + f32(a[i] * a[i]);\n bSquareSum = bSquareSum + f32(b[i] * b[i]);\n }\n var sim = productSum / (sqrt(aSquareSum) * sqrt(bSquareSum));\n return (1.0 - sim) / 2.0;\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[\"VECTOR_COSINE\"] = \"Vector Cosine\";\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.VECTOR_COSINE]: webGPUVectorCosine,\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 [WEBGPUDISTANCE.VECTOR_COSINE]: (maxEntrySize) => Math.ceil(maxEntrySize / 30)\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.VECTOR_COSINE, WEBGPUDISTANCE.SOKAL, WEBGPUDISTANCE.ASYMMETRIC, WEBGPUDISTANCE.OneHot, WEBGPUDISTANCE.Difference]),\n [\"INT32ARRAY\" /* WGPUENTRYTYPE.INT32ARRAY */]: new Set([WEBGPUDISTANCE.EUCLIDEAN, WEBGPUDISTANCE.MANHATTAN, WEBGPUDISTANCE.OneHot, WEBGPUDISTANCE.Difference, WEBGPUDISTANCE.VECTOR_COSINE]),\n [\"FLOAT32ARRAY\" /* WGPUENTRYTYPE.FLOAT32ARRAY */]: new Set([WEBGPUDISTANCE.EUCLIDEAN, WEBGPUDISTANCE.MANHATTAN, WEBGPUDISTANCE.Difference, WEBGPUDISTANCE.VECTOR_COSINE]),\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","/* 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 { 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';\nimport { getGPUDevice } from '../getGPUDevice';\n/** generate sparse matrix 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 multiColWebGPUSparseMatrix(entryList, // list of lists of entries, for multiple columns\nthreshold = 0.8, // similarity threshold, be ware that if you use too small threshold, there might be memory overflow...\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 const device = yield getGPUDevice();\n if (!device)\n return null; // if no device, return null, as we cannot do anything without it.\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 maxDistance = 1 - threshold; // maximum distance\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 ||\n options.length !== weights.length) {\n throw new Error('Options, weigths and distance functions must be provided for each column');\n }\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 numOfColumns = entryList.length; // number of columns\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 === 0) {\n throw new Error('No columns provided. Please provide at least one column of data.');\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\n .map((info) => info.suppInfoStructWgsl)\n .filter((wgsl) => !!wgsl && wgsl != '')\n .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 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 arrays 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. meaning that we will dispatch 10000 threads at a time.\n const numOfThreads = 10000;\n // in this case we do not need to worry about complexity of the algorithm, as the 100 is low enaugh number, which is limited by memory usage.\n const sparseResultSizePerThread = 100; // number of iterations per thread (number of pair comparisons)\n const combinedComplexity = processInfo.reduce((a, b) => a + b.complexity, 0); // combined complexity of all the columns\n const maxIterationsPerThread = Math.ceil(6000 / combinedComplexity); // maximum number of iterations per thread\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(numOfThreads / threadsPerWorkgroup))); // how many workgroups per 2d dimension\n const globalThreadDimSize = workgroupsDim * workGroupDivision; // how many threads per 2d dimension\n const condensedDistanceMatrixSize = listSize * (listSize - 1) / 2; // size of the condensed distance matrix, this many comparisons will be made.\n const dmChunkSizePerThread = Math.ceil(condensedDistanceMatrixSize / numOfThreads); // how many comparisons per thread\n const module = device.createShaderModule({\n label: 'Sparse matrix compute shader',\n code: `\n // each thread will perform ${sparseResultSizePerThread} iterations at one time, comparing ${sparseResultSizePerThread} pairs of entries.\n // in total, each thread will perform at most ${dmChunkSizePerThread} comparisons.\n // first is the result struct, containing is, js, and distances. each array with length of ${sparseResultSizePerThread},\n // and also integer for how many pairs were found to be below threshold.\n struct SparseResult {\n i: array<array<u32, ${sparseResultSizePerThread}>, ${numOfThreads}>,\n j: array<array<u32, ${sparseResultSizePerThread}>, ${numOfThreads}>,\n distances: array<array<f32, ${sparseResultSizePerThread}>, ${numOfThreads}>,\n found: array<u32, ${numOfThreads}>,\n done: array<u32, ${numOfThreads}>\n }\n // struct for the data\n struct ComputeInfo {\n // start at cols and rows, and end at cols and rows for each thread, these will be calculated on cpu and passed to gpu.\n startAtCols: array<u32, ${numOfThreads}>,\n startAtRows: array<u32, ${numOfThreads}>,\n endAtCols: array<u32, ${numOfThreads}>,\n endAtRows: array<u32, ${numOfThreads}>,\n\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 for the supplementary information\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> computeInfo: ComputeInfo;\n @group(0) @binding(1) var<storage, read_write> suppInfo: SuppInfo;\n @group(0) @binding(2) var<storage, read_write> results: SparseResult;\n @compute @workgroup_size(${workGroupDivision}, ${workGroupDivision}) fn calcSparseMatrix(\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 threadCol = id.x;\n let threadRow = id.y;\n let linearIndex = threadRow * ${globalThreadDimSize} + threadCol;\n if (linearIndex >= ${numOfThreads}) {\n return; // if we are out of bounds, return\n } \n var startAtCol: u32 = computeInfo.startAtCols[linearIndex];\n var startAtRow: u32 = computeInfo.startAtRows[linearIndex];\n let endAtCol: u32 = min(computeInfo.endAtCols[linearIndex], ${listSize}u);\n let endAtRow: u32 = min(computeInfo.endAtRows[linearIndex], ${listSize}u);\n let is = &results.i[linearIndex];\n let js = &results.j[linearIndex];\n let distances = &results.distances[linearIndex];\n results.found[linearIndex] = 0; // initialize the found counter\n var found: u32 = 0;\n if (results.done[linearIndex] > 0) {\n return; // if we are done, return\n }\n for (var i = 0; i < ${maxIterationsPerThread}; i++) {\n if (startAtCol >= endAtCol && startAtRow >= endAtRow) {\n results.done[linearIndex] = 1;\n break;\n }\n if (found >= ${sparseResultSizePerThread}) {\n break;\n }\n let dist = combinedDistance(startAtCol, startAtRow);\n if (dist <= ${maxDistance}) {\n (*is)[found] = startAtCol;\n (*js)[found] = startAtRow;\n (*distances)[found] = dist;\n found = found + 1;\n }\n startAtCol = startAtCol + 1;\n if (startAtCol >= ${listSize}u) {\n startAtRow += 1;\n startAtCol = startAtRow + 1;\n }\n }\n results.found[linearIndex] = found;\n // update the startAtCols and startAtRows\n computeInfo.startAtCols[linearIndex] = startAtCol;\n computeInfo.startAtRows[linearIndex] = startAtRow;\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), maxDistance, aggregationFunction)}\n\n\n `\n });\n const pipeline = device.createComputePipeline({\n label: 'sparse matrix compute pipeline',\n layout: 'auto',\n compute: {\n module,\n entryPoint: 'calcSparseMatrix',\n },\n });\n // generate startAtCols, startAtRows, endAtCols, endAtRows\n const startAtCols = new Uint32Array(numOfThreads);\n const startAtRows = new Uint32Array(numOfThreads);\n const endAtCols = new Uint32Array(numOfThreads);\n const endAtRows = new Uint32Array(numOfThreads);\n const chunkSize = Math.floor(condensedDistanceMatrixSize / numOfThreads); // size of the chunk per thread (in total)\n let startRow = 0;\n let startCol = 1;\n console.time('GPUthreadStarts');\n for (let i = 0; i < numOfThreads; i++) {\n const endIdx = i === numOfThreads - 1 ? condensedDistanceMatrixSize - 1 : (i + 1) * chunkSize;\n // fancy formulas to calculate the start and end indices for the condensed distance matrix for each thread start\n const endRow = listSize - 2 - Math.floor(Math.sqrt(-8 * endIdx + 4 * listSize * (listSize - 1) - 7) / 2 - 0.5);\n const endCol = endIdx - listSize * endRow + Math.floor((endRow + 1) * (endRow + 2) / 2);\n startAtCols[i] = startCol;\n startAtRows[i] = startRow;\n endAtCols[i] = endCol;\n endAtRows[i] = endRow;\n startRow = endRow;\n startCol = endCol;\n // const startRow = values[0].length - 2 - Math.floor(\n // Math.sqrt(-8 * startIdx + 4 * values[0].length * (values[0].length - 1) - 7) / 2 - 0.5);\n // const startCol = startIdx - values[0].length * startRow + Math.floor((startRow + 1) * (startRow + 2) / 2);\n }\n console.timeEnd('GPUthreadStarts');\n // size of the computeInfo buffer\n const computeInfoBuffer32Size = numOfThreads * 4 + // startAtCols, startAtRows, endAtCols, endAtRows\n listSize * numOfColumns + // entrySizes\n numOfColumns + // weights\n processInfo.reduce((a, b) => a + b.sourceArraySize, 0);\n // size of the suppInfo buffer\n const suppInfoBuffer32Size = processInfo.reduce((a, b) => a + b.suppInfoSize, 0);\n // size of the results buffer\n const sparseMatrixEachArray32Size = sparseResultSizePerThread * numOfThreads;\n const resultsBuffer32Size = 3 * sparseMatrixEachArray32Size + numOfThreads + numOfThreads; // i, j, distances, found, done\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 = computeInfoBuffer32Size * 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 // dynamic offset for the computeInfo buffer\n let computeInfoOffSet = 0;\n // first write the startAtCols, startAtRows, endAtCols, endAtRows\n const startAtColsBufferView = new Uint32Array(mappedComputeInfoArrayBuffer, computeInfoOffSet, numOfThreads);\n startAtColsBufferView.set(startAtCols);\n computeInfoOffSet += numOfThreads * Uint32Array.BYTES_PER_ELEMENT; // array of 32bit values\n const startAtRowsBufferView = new Uint32Array(mappedComputeInfoArrayBuffer, computeInfoOffSet, numOfThreads);\n startAtRowsBufferView.set(startAtRows);\n computeInfoOffSet += numOfThreads * Uint32Array.BYTES_PER_ELEMENT; // array of 32bit values\n const endAtColsBufferView = new Uint32Array(mappedComputeInfoArrayBuffer, computeInfoOffSet, numOfThreads);\n endAtColsBufferView.set(endAtCols);\n computeInfoOffSet += numOfThreads * Uint32Array.BYTES_PER_ELEMENT; // array of 32bit values\n const endAtRowsBufferView = new Uint32Array(mappedComputeInfoArrayBuffer, computeInfoOffSet, numOfThreads);\n endAtRowsBufferView.set(endAtRows);\n computeInfoOffSet += numOfThreads * Uint32Array.BYTES_PER_ELEMENT; // array of 32bit values\n // then write the entrySizes\n const entrySizesView = new Uint32Array(mappedComputeInfoArrayBuffer, computeInfoOffSet, arraySizes.length);\n entrySizesView.set(arraySizes);\n computeInfoOffSet += arraySizes.length * Uint32Array.BYTES_PER_ELEMENT; // array of 32bit values\n // then write the weights\n const weightsView = new Float32Array(mappedComputeInfoArrayBuffer, computeInfoOffSet, numOfColumns);\n weightsView.set(weights);\n computeInfoOffSet += numOfColumns * Float32Array.BYTES_PER_ELEMENT;\n // finally, write the data itself\n for (const info of processInfo) {\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 = suppInfoBuffer32Size * 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 // create a buffer for the results\n const resultsBufferSize = resultsBuffer32Size * Uint32Array.BYTES_PER_ELEMENT;\n let paddedResultsBufferSize = resultsBufferSize;\n const resultsRemainder = resultsBufferSize & 15; // check if the size is a multiple of 16\n if (resultsRemainder !== 0)\n paddedResultsBufferSize += 16 - resultsRemainder; // pad the size accordingly\n const resultsBuffer = device.createBuffer({\n label: 'results buffer',\n size: paddedResultsBufferSize,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC\n });\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 sparse matrix buffer',\n layout: pipeline.getBindGroupLayout(0),\n entries: [\n { binding: 0, resource: { buffer: computeInfoBuffer } },\n { binding: 1, resource: { buffer: suppInfoBuffer } },\n { binding: 2, resource: { buffer: resultsBuffer } },\n ],\n });\n //const pairComparisonsPerPass = maxIterationsPerThread * numOfThreads;\n //const passes = Math.ceil(condensedDistanceMatrixSize / pairComparisonsPerPass);\n // we will distpatch this many passes to the GPU, and it will handle indexes all by itself.\n // we already copied the start/end information to it, so it will know where to start and end on each pass.\n const resultsOutBuffer = device.createBuffer({\n label: 'results out buffer',\n size: resultsBuffer.size,\n usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,\n });\n const resultIs = [];\n const resultJs = [];\n const resultDistances = [];\n //let combinedFound = 0;\n let isAllDone = false;\n while (!isAllDone) {\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, workgroupsDim);\n pass.end();\n encoder.copyBufferToBuffer(resultsBuffer, 0, resultsOutBuffer, 0, resultsOutBuffer.size);\n // Finish encoding and submit the commands\n const commandBuffer = encoder.finish();\n device.queue.submit([commandBuffer]);\n // Read the results\n yield device.queue.onSubmittedWorkDone();\n yield resultsOutBuffer.mapAsync(GPUMapMode.READ);\n const resultsOutArrayBuffer = resultsOutBuffer.getMappedRange();\n // read the results\n let resultOffset = 0;\n const resultsI = new Uint32Array(resultsOutArrayBuffer, resultOffset, sparseMatrixEachArray32Size);\n resultOffset += sparseMatrixEachArray32Size * Uint32Array.BYTES_PER_ELEMENT;\n const resultsJ = new Uint32Array(resultsOutArrayBuffer, resultOffset, sparseMatrixEachArray32Size);\n resultOffset += sparseMatrixEachArray32Size * Uint32Array.BYTES_PER_ELEMENT;\n const resultsDistances = new Float32Array(resultsOutArrayBuffer, resultOffset, sparseMatrixEachArray32Size);\n resultOffset += sparseMatrixEachArray32Size * Float32Array.BYTES_PER_ELEMENT;\n const resultsFound = new Uint32Array(resultsOutArrayBuffer, resultOffset, numOfThreads);\n resultOffset += numOfThreads * Uint32Array.BYTES_PER_ELEMENT;\n const resultsDone = new Uint32Array(resultsOutArrayBuffer, resultOffset, numOfThreads);\n isAllDone = resultsDone.every((d) => d === 1);\n const totalResults = resultsFound.reduce((a, b) => a + b, 0);\n const combinedI = new Uint32Array(totalResults);\n const combinedJ = new Uint32Array(totalResults);\n const combinedDistances = new Float32Array(totalResults);\n let combinedOffset = 0;\n for (let resI = 0; resI < resultsFound.length; resI++) {\n const found = resultsFound[resI];\n if (found === 0)\n continue;\n combinedI.set(resultsI.subarray(resI * sparseResultSizePerThread, resI * sparseResultSizePerThread + found), combinedOffset);\n combinedJ.set(resultsJ.subarray(resI * sparseResultSizePerThread, resI * sparseResultSizePerThread + found), combinedOffset);\n combinedDistances.set(resultsDistances.subarray(resI * sparseResultSizePerThread, resI * sparseResultSizePerThread + found), combinedOffset);\n combinedOffset += found;\n }\n resultIs.push(combinedI);\n resultJs.push(combinedJ);\n resultDistances.push(combinedDistances);\n resultsOutBuffer.unmap();\n }\n const totalSize = resultIs.reduce((a, b) => a + b.length, 0);\n const finalI = new Uint32Array(totalSize);\n const finalJ = new Uint32Array(totalSize);\n const finalDistances = new Float32Array(totalSize);\n let finalOffset = 0;\n for (let i = 0; i < resultIs.length; i++) {\n finalI.set(resultIs[i], finalOffset);\n finalJ.set(resultJs[i], finalOffset);\n finalDistances.set(resultDistances[i], finalOffset);\n finalOffset += resultIs[i].length;\n }\n // as rule mandates, destroy all buffers.\n computeInfoBuffer.destroy();\n suppInfoBuffer.destroy();\n resultsBuffer.destroy();\n resultsOutBuffer.destroy();\n return { i: finalI, j: finalJ, distance: finalDistances };\n });\n}\nfunction getCombinedDistanceScript(distanceMetrics, maxEntryLens, maxDistance, 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 = ${maxDistance};\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=webGPU-sparse-matrix.js.map","import { DistanceAggregationMethods } from './types';\nimport { insertSmaller, isNil } from './utils';\nexport class SparseMatrixService {\n constructor() {\n this._workerCount = Math.max(navigator.hardwareConcurrency - 2, 1);\n }\n static pruneSparseMatrix(orig, maxNum = 1000000) {\n // bin values\n const mult = 200;\n const binRanges = new Uint32Array(mult);\n const len = orig.distance.length;\n const distances = orig.distance;\n for (let i = 0; i < len; i++) {\n const r = Math.floor(distances[i] * mult);\n binRanges[r]++;\n }\n // get the max distance\n let acum = 0;\n let maxIndex = 0;\n for (let i = 0; i < mult; i++) {\n acum += binRanges[i];\n maxIndex = i;\n if (acum >= maxNum)\n break;\n }\n const resIs = new Uint32Array(acum);\n const resJs = new Uint32Array(acum);\n const resDs = new Float32Array(acum);\n const is = orig.i;\n const js = orig.j;\n let ind = 0;\n const maxDistance = (maxIndex + 1) / mult;\n for (let i = 0; i < len; i++) {\n if (distances[i] < maxDistance) {\n resIs[ind] = is[i];\n resJs[ind] = js[i];\n resDs[ind] = distances[i];\n ind++;\n }\n }\n return { i: resIs, j: resJs, distance: resDs };\n }\n async calcMultiColumn(values, fnNames, threshold, opts = [{}], weights = [1], aggregationMethod = DistanceAggregationMethods.EUCLIDEAN) {\n const matSize = values[0].length * (values[0].length - 1) / 2;\n const chunkSize = Math.floor(matSize / this._workerCount);\n const minThreshold = values[0].length > 20000 ?\n await this.getMinimalThreshold(values, fnNames, opts, weights, aggregationMethod) : 0;\n if (threshold < minThreshold) {\n console.log(`using threshold ${minThreshold}`);\n threshold = minThreshold;\n }\n opts.forEach((_, i) => opts[i]['threshold'] = threshold);\n const promises = new Array(this._workerCount);\n const workers = new Array(this._workerCount)\n .fill(null).map(() => new Worker(new URL('./sparse-matrix-worker', import.meta.url)));\n for (let idx = 0; idx < this._workerCount; idx++) {\n promises[idx] = new Promise((resolveWorker, rejectWorker) => {\n const startIdx = idx * chunkSize;\n const endIdx = idx === this._workerCount - 1 ? matSize : (idx + 1) * chunkSize;\n if (endIdx <= startIdx)\n resolveWorker({ i: new Int32Array(0), j: new Int32Array(0), distance: new Float32Array(0), idx });\n workers[idx].postMessage({ values, startIdx, endIdx, threshold, fnNames, opts, weights, aggregationMethod });\n workers[idx].onmessage = ({ data: { error, i, j, distance } }) => {\n if (error) {\n workers[idx].terminate();\n rejectWorker(error);\n }\n else {\n workers[idx].terminate();\n resolveWorker({ i, j, distance, idx });\n }\n };\n });\n }\n const results = await Promise.all(promises);\n const fullSize = results.reduce((acc, val) => acc + val.i.length, 0);\n const i = new Int32Array(fullSize);\n const j = new Int32Array(fullSize);\n const distance = new Float32Array(fullSize);\n let offset = 0;\n // setting the results\n for (const res of results) {\n i.set(res.i, offset);\n j.set(res.j, offset);\n distance.set(res.distance, offset);\n offset += res.i.length;\n }\n return { i, j, distance };\n }\n async calc(values, fnName, threshold, opts = {}) {\n //size of full matrix\n return await this.calcMultiColumn([values], [fnName], threshold, [opts], [1]);\n }\n async getKNN(values, fnName, nNeighbours = 15, opts = {}) {\n return await this.multiColumnKNN([values], [fnName], nNeighbours, [opts], [1]);\n }\n async getThresholdKNN(values, fnName, threshold = 0.8, opts = {}) {\n return await this.multiColumnThresholdKnn([values], [fnName], threshold, [opts], [1]);\n }\n async multiColumnThresholdKnn(values, fnNames, threshold = 0.8, opts, weights, aggregationMethod = DistanceAggregationMethods.EUCLIDEAN) {\n if (values.length !== fnNames.length || values.length !== opts.length || values.length !== weights.length)\n throw new Error('values, distance functions, options and weights arrays should have the same length');\n if (values.some((v) => v.length !== values[0].length))\n throw new Error('all values arrays should have the same length');\n const matSize = values[0].length * (values[0].length - 1) / 2;\n const chunkSize = Math.floor(matSize / this._workerCount);\n const promises = new Array(this._workerCount);\n const workers = new Array(this._workerCount)\n .fill(null).map(() => new Worker(new URL('./knn-threshold-worker', import.meta.url)));\n for (let idx = 0; idx < this._workerCount; idx++) {\n promises[idx] = new Promise((resolveWorker, rejectWorker) => {\n const startIdx = idx * chunkSize;\n const endIdx = idx === this._workerCount - 1 ? matSize : (idx + 1) * chunkSize;\n if (endIdx <= startIdx)\n resolveWorker({ knnDistances: new Array(0), knnIndexes: new Array(0) });\n workers[idx].postMessage({ values, startIdx, endIdx, fnNames, opts, threshold, weights, aggregationMethod });\n workers[idx].onmessage = ({ data: { error, knnDistances, knnIndexes } }) => {\n if (error) {\n workers[idx].terminate();\n rejectWorker(error);\n }\n else {\n workers[idx].terminate();\n resolveWorker({ knnDistances, knnIndexes });\n }\n };\n });\n }\n const results = await Promise.all(promises);\n const knnSizes = new Int32Array(values[0].length);\n for (const res of results) {\n for (let i = 0; i < values[0].length; ++i)\n knnSizes[i] += res.knnIndexes[i]?.length ?? 0;\n }\n const knnRes = {\n knnDistances: new Array(values[0].length).fill(null).map((_, i) => new Array(knnSizes[i])),\n knnIndexes: new Array(values[0].length).fill(null).map((_, i) => new Array(knnSizes[i]))\n };\n for (const res of results) {\n for (let i = 0; i < values[0].length; ++i) {\n for (let j = 0; j < (res.knnDistances[i]?.length ?? 0); ++j) {\n knnRes.knnDistances[i][knnSizes[i] - 1] = res.knnDistances[i][j];\n knnRes.knnIndexes[i][knnSizes[i] - 1] = res.knnIndexes[i][j];\n knnSizes[i] -= 1;\n }\n }\n }\n return knnRes;\n }\n async multiColumnSingleValueKNN(values, targetIdx, fnNames, nNeighbours = 15, opts, weights, aggregationMethod = DistanceAggregationMethods.EUCLIDEAN) {\n if (values.length !== fnNames.length || values.length !== opts.length || values.length !== weights.length)\n throw new Error('values, distance functions, options and weights arrays should have the same length');\n if (values.some((v) => v.length !== values[0].length))\n throw new Error('all values arrays should have the same length');\n const workers = new Array(this._workerCount)\n .fill(null).map(() => new Worker(new URL('./single-value-knn-worker', import.meta.url)));\n const promises = new Array(this._workerCount);\n const fullSize = values[0].length;\n const target = values.map((v) => v[targetIdx]);\n const chunkSize = Math.ceil(fullSize / this._workerCount);\n for (let idx = 0; idx < this._workerCount; idx++) {\n promises[idx] = new Promise((resolveWorker, rejectWorker) => {\n const startIdx = idx * chunkSize;\n const endIdx = idx === this._workerCount - 1 ? fullSize : (idx + 1) * chunkSize;\n if (endIdx <= startIdx)\n resolveWorker({ knnDistances: new Array(0), knnIndexes: new Array(0) });\n workers[idx].postMessage({ values: values.map((v) => v.slice(startIdx, endIdx)), target, fnNames, opts, nNeighbours, weights, aggregationMethod, startIdx });\n workers[idx].onmessage = ({ data: { error, knnDistances, knnIndexes } }) => {\n if (error) {\n workers[idx].terminate();\n rejectWorker(error);\n }\n else {\n workers[idx].terminate();\n resolveWorker({ knnDistances, knnIndexes });\n }\n };\n });\n }\n const results = await Promise.all(promises);\n const singleValueKnn = { knnDistances: new Array(nNeighbours).fill(99999), knnIndexes: new Array(nNeighbours).fill(-1) };\n for (const res of results) {\n for (let j = 0; j < (res.knnDistances?.length ?? 0); ++j)\n insertSmaller(singleValueKnn.knnDistances, singleValueKnn.knnIndexes, res.knnDistances[j], res.knnIndexes[j]);\n }\n return singleValueKnn;\n }\n async multiColumnKNN(values, fnNames, nNeighbours = 15, opts, weights, aggregationMethod = DistanceAggregationMethods.EUCLIDEAN) {\n if (values.length !== fnNames.length || values.length !== opts.length || values.length !== weights.length)\n throw new Error('values, distance functions, options and weights arrays should have the same length');\n if (values.some((v) => v.length !== values[0].length))\n throw new Error('all values arrays should have the same length');\n const matSize = values[0].length * (values[0].length - 1) / 2;\n const chunkSize = Math.floor(matSize / this._workerCount);\n const promises = new Array(this._workerCount);\n const workers = new Array(this._workerCount)\n .fill(null).map(() => new Worker(new URL('./knn-worker', import.meta.url)));\n for (let idx = 0; idx < this._workerCount; idx++) {\n promises[idx] = new Promise((resolveWorker, rejectWorker) => {\n const startIdx = idx * chunkSize;\n const endIdx = idx === this._workerCount - 1 ? matSize : (idx + 1) * chunkSize;\n if (endIdx <= startIdx)\n resolveWorker({ knnDistances: new Array(0), knnIndexes: new Array(0) });\n workers[idx].postMessage({ values, startIdx, endIdx, fnNames, opts, nNeighbours, weights, aggregationMethod });\n workers[idx].onmessage = ({ data: { error, knnDistances, knnIndexes } }) => {\n if (error) {\n workers[idx].terminate();\n rejectWorker(error);\n }\n else {\n workers[idx].terminate();\n resolveWorker({ knnDistances, knnIndexes });\n }\n };\n });\n }\n const results = await Promise.all(promises);\n const knnRes = {\n knnDistances: new Array(values[0].length).fill(null).map(() => new Array(nNeighbours).fill(99999)),\n knnIndexes: new Array(values[0].length).fill(null).map(() => new Array(nNeighbours).fill(-1))\n };\n for (const res of results) {\n for (let i = 0; i < values[0].length; ++i) {\n for (let j = 0; j < (res.knnDistances[i]?.length ?? 0); ++j)\n insertSmaller(knnRes.knnDistances[i], knnRes.knnIndexes[i], res.knnDistances[i][j], res.knnIndexes[i][j]);\n }\n }\n return knnRes;\n }\n async getSampleDistances(values, fnNames, opts = [], weights, aggregationMethod = DistanceAggregationMethods.EUCLIDEAN) {\n const thresholdWorkers = new Array(this._workerCount).fill(null)\n .map(() => new Worker(new URL('./sparse-matrix-threshold-worker', import.meta.url)));\n try {\n const matSize = values[0].length * (values[0].length - 1) / 2;\n const chunkSize = Math.floor(matSize / this._workerCount);\n const maxSampleSize = 1000000;\n const sampleSise = Math.max(Math.min(matSize / 1000, maxSampleSize), Math.min(matSize, maxSampleSize));\n const testSetSizePerWorker = Math.floor(sampleSise / this._workerCount);\n const tPromises = new Array(this._workerCount);\n for (let idx = 0; idx < this._workerCount; idx++) {\n tPromises[idx] = new Promise((resolveWorker, rejectWorker) => {\n const startIdx = idx * chunkSize;\n const endIdx = idx === this._workerCount - 1 ? matSize : (idx + 1) * chunkSize;\n thresholdWorkers[idx].postMessage({\n values: values, startIdx, endIdx, sampleLength: testSetSizePerWorker,\n fnNames, opts, weights, aggregationMethod\n });\n thresholdWorkers[idx].onmessage = ({ data: { error, distance } }) => {\n thresholdWorkers[idx].terminate();\n if (error)\n rejectWorker(error);\n else\n resolveWorker({ distance });\n };\n });\n }\n const results = await Promise.all(tPromises);\n const fullSize = results.reduce((acc, val) => acc + val.distance.length, 0);\n const distance = new Float32Array(fullSize);\n let offset = 0;\n for (const res of results) {\n distance.set(res.distance, offset);\n offset += res.distance.length;\n }\n distance.sort();\n return distance;\n }\n catch (e) {\n thresholdWorkers?.forEach((w) => w?.terminate());\n console.error(e);\n return new Float32Array(1).fill(0.5);\n }\n }\n async getMinimalThreshold(values, fnNames, opts = [], weights, aggregationMethod = DistanceAggregationMethods.EUCLIDEAN) {\n //We need to calculate the minimal threshold first,\n //in order to get matrix such that it does not exceed the maximum size of 1GB\n //we have 3 return arrays, each 4 bites per element, so if the maximum size of the matrix is 1GB,\n const maxSparseMatrixSize = 70000000;\n try {\n const matSize = values.length * (values.length - 1) / 2;\n const distance = await this.getSampleDistances(values, fnNames, opts, weights, aggregationMethod);\n const fractionIndex = Math.floor(maxSparseMatrixSize / matSize * distance.length);\n const threshold = 1 - distance[fractionIndex];\n // threshold = Math.max(threshold, 0.3);\n return threshold;\n }\n catch (e) {\n console.error(e);\n return 0.5;\n }\n }\n static calcSync(values, fnName, distanceFn, threshold) {\n const i = [];\n const j = [];\n const distances = [];\n let cnt = 0;\n let mi = 0;\n let mj = 0;\n const fullSize = values.length * (values.length - 1) / 2;\n while (cnt < fullSize) {\n //const value = seq1List[mi] && seq1List[mj] ? hamming(seq1List[mi], seq1List[mj]) : 0;\n const value = !isNil(values[mi]) && !isNil(values[mj]) ?\n distanceFn(values[mi], values[mj]) : 1;\n const similarity = 1 - value;\n if (similarity >= threshold) {\n i.push(mi);\n j.push(mj);\n distances.push(value);\n }\n cnt++;\n mj++;\n if (mj === values.length) {\n mi++;\n mj = mi + 1;\n }\n }\n const iArray = new Int32Array(i);\n const jArray = new Int32Array(j);\n const distanceArray = new Float32Array(distances);\n return { i: iArray, j: jArray, distance: distanceArray };\n }\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sparse-matrix-service.js","sourceRoot":"","sources":["sparse-matrix-service.ts"],"names":[],"mappings":"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","sourcesContent":["import {KnownMetrics} from '../typed-metrics';\nimport {DistanceAggregationMethod, DistanceAggregationMethods} from './types';\nimport {insertSmaller, isNil} from './utils';\n\nexport type SparseMatrixResult = {\n  i: Int32Array | Uint32Array,\n  j: Int32Array | Uint32Array,\n  distance: Float32Array,\n  idx?: number\n};\n\nexport type KnnResult = {\n  knnDistances: number[][],\n  knnIndexes: number[][]\n}\nexport class SparseMatrixService {\n    private _workerCount: number;\n    constructor() {\n      this._workerCount = Math.max(navigator.hardwareConcurrency - 2, 1);\n    }\n\n    static pruneSparseMatrix(orig: SparseMatrixResult, maxNum = 1_000_000): SparseMatrixResult {\n      // bin values\n      const mult = 200;\n      const binRanges = new Uint32Array(mult);\n      const len = orig.distance.length;\n      const distances = orig.distance;\n      for (let i = 0; i < len; i++) {\n        const r = Math.floor(distances[i] * mult);\n        binRanges[r]++;\n      }\n\n      // get the max distance\n      let acum = 0;\n      let maxIndex = 0\n      for (let i = 0; i < mult; i++) {\n        acum += binRanges[i];\n        maxIndex = i;\n        if (acum >= maxNum)\n          break;\n      }\n      \n      const resIs = new Uint32Array(acum);\n      const resJs = new Uint32Array(acum);\n      const resDs = new Float32Array(acum);\n      const is = orig.i;\n      const js = orig.j;\n      let ind = 0;\n      const maxDistance = (maxIndex + 1) / mult;\n      for (let i = 0; i < len; i++) {\n        if (distances[i] < maxDistance) {\n          resIs[ind] = is[i];\n          resJs[ind] = js[i];\n          resDs[ind] = distances[i];\n          ind ++;\n        }\n      }\n      return {i: resIs, j: resJs, distance: resDs};\n    }\n\n    public async calcMultiColumn(values: Array<any[]>, fnNames: KnownMetrics[],\n      threshold: number, opts: {[_: string]: any}[] = [{}], weights: number[] = [1],\n      aggregationMethod: DistanceAggregationMethod = DistanceAggregationMethods.EUCLIDEAN\n    ) {\n      const matSize = values[0].length * (values[0].length - 1) / 2;\n      const chunkSize = Math.floor(matSize / this._workerCount);\n\n      const minThreshold = values[0].length > 20_000 ?\n        await this.getMinimalThreshold(values, fnNames, opts, weights, aggregationMethod) : 0;\n      if (threshold < minThreshold) {\n        console.log(`using threshold ${minThreshold}`);\n        threshold = minThreshold;\n      }\n      opts.forEach((_, i) => opts[i]['threshold'] = threshold);\n      const promises =\n        new Array<Promise<SparseMatrixResult>>(this._workerCount);\n\n      const workers = new Array(this._workerCount)\n        .fill(null).map(() => new Worker(new URL('./sparse-matrix-worker', import.meta.url)));\n      for (let idx = 0; idx < this._workerCount; idx++) {\n        promises[idx] = new Promise((resolveWorker, rejectWorker) => {\n          const startIdx = idx * chunkSize;\n          const endIdx = idx === this._workerCount - 1 ? matSize : (idx + 1) * chunkSize;\n          if (endIdx <= startIdx)\n            resolveWorker({i: new Int32Array(0), j: new Int32Array(0), distance: new Float32Array(0), idx});\n          workers[idx].postMessage({values, startIdx, endIdx, threshold, fnNames, opts, weights, aggregationMethod});\n          workers[idx].onmessage = ({data: {error, i, j, distance}}): void => {\n            if (error) {\n              workers[idx].terminate();\n              rejectWorker(error);\n            } else {\n              workers[idx].terminate();\n              resolveWorker({i, j, distance, idx});\n            }\n          };\n        });\n      }\n\n      const results = await Promise.all(promises);\n      const fullSize = results.reduce((acc, val) => acc + val.i.length, 0);\n      const i = new Int32Array(fullSize);\n      const j = new Int32Array(fullSize);\n      const distance = new Float32Array(fullSize);\n      let offset = 0;\n      // setting the results\n      for (const res of results) {\n        i.set(res.i, offset);\n        j.set(res.j, offset);\n        distance.set(res.distance, offset);\n        offset += res.i.length;\n      }\n      return {i, j, distance};\n    }\n\n    public async calc<T>(values: Array<T>, fnName: KnownMetrics, threshold: number, opts: {[_: string]: any} = {}) {\n      //size of full matrix\n      return await this.calcMultiColumn([values], [fnName], threshold, [opts], [1]);\n    }\n\n    public async getKNN(\n      values: Array<any>, fnName: KnownMetrics, nNeighbours: number = 15, opts: {[_: string]: any} = {}\n    ) {\n      return await this.multiColumnKNN([values], [fnName], nNeighbours, [opts], [1]);\n    }\n\n    public async getThresholdKNN(\n      values: Array<any>, fnName: KnownMetrics, threshold: number = 0.8, opts: {[_: string]: any} = {}\n    ) {\n      return await this.multiColumnThresholdKnn([values], [fnName], threshold, [opts], [1]);\n    }\n\n    public async multiColumnThresholdKnn(values: Array<Array<any>>, fnNames: KnownMetrics[], threshold: number = 0.8,\n      opts: {[_: string]: any}[], weights: number[],\n      aggregationMethod: DistanceAggregationMethod = DistanceAggregationMethods.EUCLIDEAN\n    ) {\n      if (values.length !== fnNames.length || values.length !== opts.length || values.length !== weights.length)\n        throw new Error('values, distance functions, options and weights arrays should have the same length');\n\n      if (values.some((v) => v.length !== values[0].length))\n        throw new Error('all values arrays should have the same length');\n\n      const matSize = values[0].length * (values[0].length - 1) / 2;\n      const chunkSize = Math.floor(matSize / this._workerCount);\n      const promises =\n        new Array<Promise<KnnResult>>(this._workerCount);\n      const workers = new Array(this._workerCount)\n        .fill(null).map(() => new Worker(new URL('./knn-threshold-worker', import.meta.url)));\n      for (let idx = 0; idx < this._workerCount; idx++) {\n        promises[idx] = new Promise((resolveWorker, rejectWorker) => {\n          const startIdx = idx * chunkSize;\n          const endIdx = idx === this._workerCount - 1 ? matSize : (idx + 1) * chunkSize;\n          if (endIdx <= startIdx)\n            resolveWorker({knnDistances: new Array(0), knnIndexes: new Array(0)});\n          workers[idx].postMessage({values, startIdx, endIdx, fnNames, opts, threshold, weights, aggregationMethod});\n          workers[idx].onmessage = ({data: {error, knnDistances, knnIndexes}}): void => {\n            if (error) {\n              workers[idx].terminate();\n              rejectWorker(error);\n            } else {\n              workers[idx].terminate();\n              resolveWorker({knnDistances, knnIndexes});\n            }\n          };\n        });\n      }\n\n      const results = await Promise.all(promises);\n      const knnSizes = new Int32Array(values[0].length);\n      for (const res of results) {\n        for (let i = 0; i < values[0].length; ++i)\n          knnSizes[i] += res.knnIndexes[i]?.length ?? 0;\n      }\n      const knnRes: KnnResult = {\n        knnDistances: new Array(values[0].length).fill(null).map((_, i) => new Array<number>(knnSizes[i])),\n        knnIndexes: new Array(values[0].length).fill(null).map((_, i) => new Array<number>(knnSizes[i]))};\n      for (const res of results) {\n        for (let i = 0; i < values[0].length; ++i) {\n          for (let j = 0; j < (res.knnDistances[i]?.length ?? 0); ++j) {\n            knnRes.knnDistances[i][knnSizes[i] - 1] = res.knnDistances[i][j];\n            knnRes.knnIndexes[i][knnSizes[i] - 1] = res.knnIndexes[i][j];\n            knnSizes[i] -= 1;\n          }\n        }\n      }\n      return knnRes;\n    }\n\n    public async multiColumnSingleValueKNN(values: Array<any[]>, targetIdx: number, fnNames: KnownMetrics[], nNeighbours: number = 15,\n      opts: {[_: string]: any}[], weights: number[], aggregationMethod: DistanceAggregationMethod = DistanceAggregationMethods.EUCLIDEAN\n    ) {\n      if (values.length !== fnNames.length || values.length !== opts.length || values.length !== weights.length)\n        throw new Error('values, distance functions, options and weights arrays should have the same length');\n\n      if (values.some((v) => v.length !== values[0].length))\n        throw new Error('all values arrays should have the same length');\n\n      const workers = new Array(this._workerCount)\n        .fill(null).map(() => new Worker(new URL('./single-value-knn-worker', import.meta.url)));\n      const promises =\n        new Array<Promise<{knnDistances: Array<number>, knnIndexes: Array<number>}>>(this._workerCount);\n      const fullSize = values[0].length;\n      const target = values.map((v) => v[targetIdx]);\n      const chunkSize = Math.ceil(fullSize / this._workerCount);\n      for (let idx = 0; idx < this._workerCount; idx++) {\n        promises[idx] = new Promise((resolveWorker, rejectWorker) => {\n          const startIdx = idx * chunkSize;\n          const endIdx = idx === this._workerCount - 1 ? fullSize : (idx + 1) * chunkSize;\n          if (endIdx <= startIdx)\n            resolveWorker({knnDistances: new Array(0), knnIndexes: new Array(0)});\n          workers[idx].postMessage({values: values.map((v) => v.slice(startIdx, endIdx)), target, fnNames, opts, nNeighbours, weights, aggregationMethod, startIdx});\n          workers[idx].onmessage = ({data: {error, knnDistances, knnIndexes}}): void => {\n            if (error) {\n              workers[idx].terminate();\n              rejectWorker(error);\n            } else {\n              workers[idx].terminate();\n              resolveWorker({knnDistances, knnIndexes});\n            }\n          };\n        });\n      }\n\n      const results = await Promise.all(promises);\n      const singleValueKnn = {knnDistances: new Array(nNeighbours).fill(99999) , knnIndexes: new Array(nNeighbours).fill(-1)} as {knnDistances: Array<number>, knnIndexes: Array<number>};\n\n      for (const res of results) {\n          for (let j = 0; j < (res.knnDistances?.length ?? 0); ++j)\n            insertSmaller(singleValueKnn.knnDistances, singleValueKnn.knnIndexes, res.knnDistances[j], res.knnIndexes[j]);\n      }\n      return singleValueKnn;\n    }\n\n    public async multiColumnKNN(values: Array<Array<any>>, fnNames: KnownMetrics[], nNeighbours: number = 15,\n      opts: {[_: string]: any}[], weights: number[],\n      aggregationMethod: DistanceAggregationMethod = DistanceAggregationMethods.EUCLIDEAN\n    ) {\n      if (values.length !== fnNames.length || values.length !== opts.length || values.length !== weights.length)\n        throw new Error('values, distance functions, options and weights arrays should have the same length');\n\n      if (values.some((v) => v.length !== values[0].length))\n        throw new Error('all values arrays should have the same length');\n\n      const matSize = values[0].length * (values[0].length - 1) / 2;\n      const chunkSize = Math.floor(matSize / this._workerCount);\n      const promises =\n        new Array<Promise<KnnResult>>(this._workerCount);\n      const workers = new Array(this._workerCount)\n        .fill(null).map(() => new Worker(new URL('./knn-worker', import.meta.url)));\n      for (let idx = 0; idx < this._workerCount; idx++) {\n        promises[idx] = new Promise((resolveWorker, rejectWorker) => {\n          const startIdx = idx * chunkSize;\n          const endIdx = idx === this._workerCount - 1 ? matSize : (idx + 1) * chunkSize;\n          if (endIdx <= startIdx)\n            resolveWorker({knnDistances: new Array(0), knnIndexes: new Array(0)});\n          workers[idx].postMessage({values, startIdx, endIdx, fnNames, opts, nNeighbours, weights, aggregationMethod});\n          workers[idx].onmessage = ({data: {error, knnDistances, knnIndexes}}): void => {\n            if (error) {\n              workers[idx].terminate();\n              rejectWorker(error);\n            } else {\n              workers[idx].terminate();\n              resolveWorker({knnDistances, knnIndexes});\n            }\n          };\n        });\n      }\n\n      const results = await Promise.all(promises);\n      const knnRes: KnnResult = {\n        knnDistances: new Array(values[0].length).fill(null).map(() => new Array<number>(nNeighbours).fill(99999)),\n        knnIndexes: new Array(values[0].length).fill(null).map(() => new Array<number>(nNeighbours).fill(-1))};\n      for (const res of results) {\n        for (let i = 0; i < values[0].length; ++i) {\n          for (let j = 0; j < (res.knnDistances[i]?.length ?? 0); ++j)\n            insertSmaller(knnRes.knnDistances[i], knnRes.knnIndexes[i], res.knnDistances[i][j], res.knnIndexes[i][j]);\n        }\n      }\n      return knnRes;\n    }\n\n    public async getSampleDistances(values: Array<any[]>,\n      fnNames: KnownMetrics[], opts: {[_: string]: any}[] = [], weights: number[],\n      aggregationMethod: DistanceAggregationMethod = DistanceAggregationMethods.EUCLIDEAN): Promise<Float32Array> {\n      const thresholdWorkers = new Array(this._workerCount).fill(null)\n        .map(() => new Worker(new URL('./sparse-matrix-threshold-worker', import.meta.url)));\n\n      try {\n        const matSize = values[0].length * (values[0].length - 1) / 2;\n        const chunkSize = Math.floor(matSize / this._workerCount);\n        const maxSampleSize = 1_000_000;\n        const sampleSise = Math.max(Math.min(matSize / 1000, maxSampleSize), Math.min(matSize, maxSampleSize));\n        const testSetSizePerWorker = Math.floor(sampleSise / this._workerCount);\n        const tPromises = new Array<Promise<{distance: Float32Array}>>(this._workerCount);\n\n        for (let idx = 0; idx < this._workerCount; idx++) {\n          tPromises[idx] = new Promise((resolveWorker, rejectWorker) => {\n            const startIdx = idx * chunkSize;\n            const endIdx = idx === this._workerCount - 1 ? matSize : (idx + 1) * chunkSize;\n            thresholdWorkers[idx].postMessage({\n              values: values, startIdx, endIdx, sampleLength: testSetSizePerWorker,\n              fnNames, opts, weights, aggregationMethod\n            });\n            thresholdWorkers[idx].onmessage = ({data: {error, distance}}): void => {\n              thresholdWorkers[idx].terminate();\n              if (error) rejectWorker(error); else\n                resolveWorker({distance});\n            };\n          });\n        }\n\n        const results = await Promise.all(tPromises);\n        const fullSize = results.reduce((acc, val) => acc + val.distance.length, 0);\n        const distance = new Float32Array(fullSize);\n        let offset = 0;\n        for (const res of results) {\n          distance.set(res.distance, offset);\n          offset += res.distance.length;\n        }\n        distance.sort();\n\n        return distance;\n      } catch (e) {\n        thresholdWorkers?.forEach((w) => w?.terminate());\n        console.error(e);\n        return new Float32Array(1).fill(0.5);\n      }\n    }\n\n    private async getMinimalThreshold(values: Array<any[]>,\n      fnNames: KnownMetrics[], opts: {[_: string]: any}[] = [], weights: number[],\n      aggregationMethod: DistanceAggregationMethod = DistanceAggregationMethods.EUCLIDEAN) {\n      //We need to calculate the minimal threshold first,\n      //in order to get matrix such that it does not exceed the maximum size of 1GB\n      //we have 3 return arrays, each 4 bites per element, so if the maximum size of the matrix is 1GB,\n      const maxSparseMatrixSize = 70_000_000;\n      try {\n        const matSize = values.length * (values.length - 1) / 2;\n        const distance = await this.getSampleDistances(values, fnNames, opts, weights, aggregationMethod);\n        const fractionIndex = Math.floor(maxSparseMatrixSize / matSize * distance.length);\n        const threshold = 1 - distance[fractionIndex];\n        // threshold = Math.max(threshold, 0.3);\n        return threshold;\n      } catch (e) {\n        console.error(e);\n        return 0.5;\n      }\n    }\n\n    public static calcSync<T>(\n      values: Array<T> | ArrayLike<T>, fnName: KnownMetrics, distanceFn: Function, threshold: number\n    ) {\n      const i: number[] = [];\n      const j: number[] = [];\n      const distances: number[] = [];\n      let cnt = 0;\n      let mi = 0;\n      let mj = 0;\n      const fullSize = values.length * (values.length - 1) / 2;\n      while (cnt < fullSize) {\n        //const value = seq1List[mi] && seq1List[mj] ? hamming(seq1List[mi], seq1List[mj]) : 0;\n        const value = !isNil(values[mi]) && !isNil(values[mj]) ?\n          distanceFn(values[mi], values[mj]) : 1;\n        const similarity = 1 - value;\n        if (similarity >= threshold) {\n          i.push(mi);\n          j.push(mj);\n          distances.push(value);\n        }\n        cnt++;\n        mj++;\n        if (mj === values.length) {\n          mi++;\n          mj = mi + 1;\n        }\n      }\n\n      const iArray = new Int32Array(i);\n      const jArray = new Int32Array(j);\n      const distanceArray = new Float32Array(distances);\n\n      return {i: iArray, j: jArray, distance: distanceArray};\n    }\n}\n"]}"],"names":[],"sourceRoot":""}