w-cluster 1.0.19 → 1.0.21

package/src/k-medoids/test.mjs

@@ -0,0 +1,357 @@
+// Translated unit tests for rust-kmedoids -> JS port.
+// Self-contained Node test runner. Run with: node test.mjs
+//
+// Ported faithfully from the Rust #[cfg(test)] modules in src/*.rs.
+// Each algorithm MUTATES the medoid array passed in, so every test case
+// builds a FRESH med array.
+
+import * as km from './index.mjs';
+import { LowerTriangle, DenseMatrix } from './arrayadapter.mjs';
+
+// ---- tiny harness ----------------------------------------------------------
+let passed = 0;
+let failed = 0;
+
+function check(name, cond) {
+  if (cond) {
+    passed++;
+    console.log(`PASS  ${name}`);
+  } else {
+    failed++;
+    console.log(`FAIL  ${name}`);
+  }
+}
+
+function eqArr(a, b) {
+  if (!Array.isArray(a) || !Array.isArray(b)) return false;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+
+function near(a, b) {
+  return Math.abs(a - b) < 1e-9;
+}
+
+// The standard small dataset (LowerTriangle, n=5, without diagonal).
+const D = new LowerTriangle(5, [1, 2, 3, 4, 5, 6, 7, 8, 9, 1]);
+
+// ============================================================================
+// FasterPAM
+// ============================================================================
+{
+  // fasterpam(D, [0,1], 10): loss=4, nSwaps=2, nIter=2, assi=[0,0,0,1,1], med=[0,3]
+  const med = [0, 1];
+  const r = km.fasterpam(D, med, 10);
+  const sil = km.silhouette(D, r.assi, false).sil;
+  check('fasterpam simple: loss', near(r.loss, 4));
+  check('fasterpam simple: nSwaps', r.nSwaps === 2);
+  check('fasterpam simple: nIter', r.nIter === 2);
+  check('fasterpam simple: assi', eqArr(r.assi, [0, 0, 0, 1, 1]));
+  check('fasterpam simple: med', eqArr(med, [0, 3]));
+  check('fasterpam simple: sil', near(sil, 0.7522494172494172));
+}
+{
+  // fasterpam(D, [1], 10): loss=14, nSwaps=1, nIter=1, assi=[0,0,0,0,0], med=[0]
+  const med = [1];
+  const r = km.fasterpam(D, med, 10);
+  const sil = km.silhouette(D, r.assi, false).sil;
+  check('fasterpam single-cluster: loss', near(r.loss, 14));
+  check('fasterpam single-cluster: nSwaps', r.nSwaps === 1);
+  check('fasterpam single-cluster: nIter', r.nIter === 1);
+  check('fasterpam single-cluster: assi', eqArr(r.assi, [0, 0, 0, 0, 0]));
+  check('fasterpam single-cluster: med', eqArr(med, [0]));
+  check('fasterpam single-cluster: sil', near(sil, 0));
+}
+
+// ============================================================================
+// FastPAM1
+// ============================================================================
+{
+  // fastpam1(D, [0,1], 10): loss=4, nSwaps=1, nIter=2, assi=[0,0,0,1,1], med=[0,3]
+  const med = [0, 1];
+  const r = km.fastpam1(D, med, 10);
+  const sil = km.silhouette(D, r.assi, false).sil;
+  check('fastpam1 simple: loss', near(r.loss, 4));
+  check('fastpam1 simple: nSwaps', r.nSwaps === 1);
+  check('fastpam1 simple: nIter', r.nIter === 2);
+  check('fastpam1 simple: assi', eqArr(r.assi, [0, 0, 0, 1, 1]));
+  check('fastpam1 simple: med', eqArr(med, [0, 3]));
+  check('fastpam1 simple: sil', near(sil, 0.7522494172494172));
+}
+
+// ============================================================================
+// Alternating
+// ============================================================================
+{
+  // alternating(D, [0,1], 10): nIter=3, loss=4, assi=[1,1,1,0,0], med=[3,0]
+  const med = [0, 1];
+  const r = km.alternating(D, med, 10);
+  const sil = km.silhouette(D, r.assi, false).sil;
+  check('alternating: nIter', r.nIter === 3);
+  check('alternating: loss', near(r.loss, 4));
+  check('alternating: assi', eqArr(r.assi, [1, 1, 1, 0, 0]));
+  check('alternating: med', eqArr(med, [3, 0]));
+  check('alternating: sil', near(sil, 0.7522494172494172));
+}
+
+// ============================================================================
+// PAM
+// ============================================================================
+{
+  // pam_swap(D, [0,1], 10): loss=4, nSwaps=1, nIter=2, assi=[0,0,0,1,1], med=[0,3]
+  const med = [0, 1];
+  const r = km.pam_swap(D, med, 10);
+  const sil = km.silhouette(D, r.assi, false).sil;
+  check('pam_swap: loss', near(r.loss, 4));
+  check('pam_swap: nSwaps', r.nSwaps === 1);
+  check('pam_swap: nIter', r.nIter === 2);
+  check('pam_swap: assi', eqArr(r.assi, [0, 0, 0, 1, 1]));
+  check('pam_swap: med', eqArr(med, [0, 3]));
+  check('pam_swap: sil', near(sil, 0.7522494172494172));
+}
+{
+  // pam_build(D, 2): loss=4, assi=[0,0,0,1,1], meds=[0,3]
+  const r = km.pam_build(D, 2);
+  const sil = km.silhouette(D, r.assi, false).sil;
+  check('pam_build: loss', near(r.loss, 4));
+  check('pam_build: assi', eqArr(r.assi, [0, 0, 0, 1, 1]));
+  check('pam_build: meds', eqArr(r.meds, [0, 3]));
+  check('pam_build: sil', near(sil, 0.7522494172494172));
+}
+{
+  // pam(D, 2, 10): nSwaps=0, nIter=1, loss=4, assi=[0,0,0,1,1], meds=[0,3]
+  const r = km.pam(D, 2, 10);
+  const sil = km.silhouette(D, r.assi, false).sil;
+  check('pam: nSwaps', r.nSwaps === 0);
+  check('pam: nIter', r.nIter === 1);
+  check('pam: loss', near(r.loss, 4));
+  check('pam: assi', eqArr(r.assi, [0, 0, 0, 1, 1]));
+  check('pam: meds', eqArr(r.meds, [0, 3]));
+  check('pam: sil', near(sil, 0.7522494172494172));
+}
+
+// ============================================================================
+// FastMSC
+// ============================================================================
+{
+  // fastmsc(D, [0,1,2], 10): loss=0.9047619047619048, nSwaps=1, nIter=2,
+  //   assi=[0,0,2,1,1], med=[0,3,2]
+  const med = [0, 1, 2];
+  const r = km.fastmsc(D, med, 10);
+  const sil = km.silhouette(D, r.assi, false).sil;
+  const msil = km.medoid_silhouette(D, med, false).sil;
+  check('fastmsc k3: loss', near(r.loss, 0.9047619047619048));
+  check('fastmsc k3: msil', near(msil, 0.9047619047619048));
+  check('fastmsc k3: nSwaps', r.nSwaps === 1);
+  check('fastmsc k3: nIter', r.nIter === 2);
+  check('fastmsc k3: assi', eqArr(r.assi, [0, 0, 2, 1, 1]));
+  check('fastmsc k3: med', eqArr(med, [0, 3, 2]));
+  check('fastmsc k3: sil', near(sil, 0.5622222222222222));
+}
+{
+  // fastmsc(D, [0,1], 10): loss=0.8805555555555555, nSwaps=1, nIter=2,
+  //   assi=[0,0,0,1,1], med=[0,4]
+  const med = [0, 1];
+  const r = km.fastmsc(D, med, 10);
+  const sil = km.silhouette(D, r.assi, false).sil;
+  const msil = km.medoid_silhouette(D, med, false).sil;
+  check('fastmsc k2: loss', near(r.loss, 0.8805555555555555));
+  check('fastmsc k2: msil', near(msil, 0.8805555555555555));
+  check('fastmsc k2: nSwaps', r.nSwaps === 1);
+  check('fastmsc k2: nIter', r.nIter === 2);
+  check('fastmsc k2: assi', eqArr(r.assi, [0, 0, 0, 1, 1]));
+  check('fastmsc k2: med', eqArr(med, [0, 4]));
+  check('fastmsc k2: sil', near(sil, 0.7522494172494172));
+}
+
+// ============================================================================
+// FasterMSC
+// ============================================================================
+{
+  // fastermsc(D, [0,1,2], 10): loss=0.9047619047619048, nSwaps=1, nIter=2,
+  //   assi=[0,0,2,1,1], med=[0,3,2]
+  const med = [0, 1, 2];
+  const r = km.fastermsc(D, med, 10);
+  const sil = km.silhouette(D, r.assi, false).sil;
+  const msil = km.medoid_silhouette(D, med, false).sil;
+  check('fastermsc k3: loss', near(r.loss, 0.9047619047619048));
+  check('fastermsc k3: msil', near(msil, 0.9047619047619048));
+  check('fastermsc k3: nSwaps', r.nSwaps === 1);
+  check('fastermsc k3: nIter', r.nIter === 2);
+  check('fastermsc k3: assi', eqArr(r.assi, [0, 0, 2, 1, 1]));
+  check('fastermsc k3: med', eqArr(med, [0, 3, 2]));
+  check('fastermsc k3: sil', near(sil, 0.5622222222222222));
+}
+{
+  // fastermsc(D, [0,1], 10): loss=0.8805555555555555, nSwaps=3, nIter=2,
+  //   assi=[0,0,0,1,1], med=[0,4]
+  const med = [0, 1];
+  const r = km.fastermsc(D, med, 10);
+  const sil = km.silhouette(D, r.assi, false).sil;
+  const msil = km.medoid_silhouette(D, med, false).sil;
+  check('fastermsc k2: loss', near(r.loss, 0.8805555555555555));
+  check('fastermsc k2: msil', near(msil, 0.8805555555555555));
+  check('fastermsc k2: nSwaps', r.nSwaps === 3);
+  check('fastermsc k2: nIter', r.nIter === 2);
+  check('fastermsc k2: assi', eqArr(r.assi, [0, 0, 0, 1, 1]));
+  check('fastermsc k2: med', eqArr(med, [0, 4]));
+  check('fastermsc k2: sil', near(sil, 0.7522494172494172));
+}
+
+// ============================================================================
+// PAMSIL
+// ============================================================================
+{
+  // pamsil(D, 2, 10): nSwaps=1, nIter=2, loss=0.7522494172494172,
+  //   assi=[0,0,0,1,1], meds=[1,3]
+  const r = km.pamsil(D, 2, 10);
+  const sil = km.silhouette(D, r.assi, false).sil;
+  check('pamsil k2: nSwaps', r.nSwaps === 1);
+  check('pamsil k2: nIter', r.nIter === 2);
+  check('pamsil k2: loss', near(r.loss, 0.7522494172494172));
+  check('pamsil k2: assi', eqArr(r.assi, [0, 0, 0, 1, 1]));
+  check('pamsil k2: meds', eqArr(r.meds, [1, 3]));
+  check('pamsil k2: sil', near(sil, 0.7522494172494172));
+}
+{
+  // pamsil(D, 3, 10): nSwaps=1, nIter=2, loss=0.5622222222222222,
+  //   assi=[0,0,2,1,1], meds=[1,3,2]
+  const r = km.pamsil(D, 3, 10);
+  const sil = km.silhouette(D, r.assi, false).sil;
+  check('pamsil k3: nSwaps', r.nSwaps === 1);
+  check('pamsil k3: nIter', r.nIter === 2);
+  check('pamsil k3: loss', near(r.loss, 0.5622222222222222));
+  check('pamsil k3: assi', eqArr(r.assi, [0, 0, 2, 1, 1]));
+  check('pamsil k3: meds', eqArr(r.meds, [1, 3, 2]));
+  check('pamsil k3: sil', near(sil, 0.5622222222222222));
+}
+{
+  // pamsil_swap(D, [0,1,2], 10): loss=0.5622222222222222, nSwaps=1, nIter=2,
+  //   assi=[1,1,2,0,0], med=[3,1,2]
+  const med = [0, 1, 2];
+  const r = km.pamsil_swap(D, med, 10);
+  const sil = km.silhouette(D, r.assi, false).sil;
+  check('pamsil_swap: loss', near(r.loss, 0.5622222222222222));
+  check('pamsil_swap: nSwaps', r.nSwaps === 1);
+  check('pamsil_swap: nIter', r.nIter === 2);
+  check('pamsil_swap: assi', eqArr(r.assi, [1, 1, 2, 0, 0]));
+  check('pamsil_swap: med', eqArr(med, [3, 1, 2]));
+  check('pamsil_swap: sil', near(sil, 0.5622222222222222));
+}
+
+// ============================================================================
+// PAMMEDSIL
+// ============================================================================
+{
+  // pammedsil(D, 3, 10): nSwaps=0, nIter=1, loss=0.9047619047619048,
+  //   assi=[0,0,2,1,1], meds=[0,3,2]
+  const r = km.pammedsil(D, 3, 10);
+  const sil = km.silhouette(D, r.assi, false).sil;
+  const msil = km.medoid_silhouette(D, r.meds, false).sil;
+  check('pammedsil: nSwaps', r.nSwaps === 0);
+  check('pammedsil: nIter', r.nIter === 1);
+  check('pammedsil: loss', near(r.loss, 0.9047619047619048));
+  check('pammedsil: msil', near(msil, 0.9047619047619048));
+  check('pammedsil: assi', eqArr(r.assi, [0, 0, 2, 1, 1]));
+  check('pammedsil: meds', eqArr(r.meds, [0, 3, 2]));
+  check('pammedsil: sil', near(sil, 0.5622222222222222));
+}
+{
+  // pammedsil_swap(D, [0,1,2], 10): loss=0.9047619047619048, nSwaps=1, nIter=2,
+  //   assi=[0,0,2,1,1], med=[0,3,2]
+  const med = [0, 1, 2];
+  const r = km.pammedsil_swap(D, med, 10);
+  const sil = km.silhouette(D, r.assi, false).sil;
+  const msil = km.medoid_silhouette(D, med, false).sil;
+  check('pammedsil_swap k3: loss', near(r.loss, 0.9047619047619048));
+  check('pammedsil_swap k3: msil', near(msil, 0.9047619047619048));
+  check('pammedsil_swap k3: nSwaps', r.nSwaps === 1);
+  check('pammedsil_swap k3: nIter', r.nIter === 2);
+  check('pammedsil_swap k3: assi', eqArr(r.assi, [0, 0, 2, 1, 1]));
+  check('pammedsil_swap k3: med', eqArr(med, [0, 3, 2]));
+  check('pammedsil_swap k3: sil', near(sil, 0.5622222222222222));
+}
+{
+  // pammedsil_swap(D, [0,1], 10): loss=0.8805555555555555, nSwaps=1, nIter=2,
+  //   assi=[0,0,0,1,1], med=[0,4]
+  const med = [0, 1];
+  const r = km.pammedsil_swap(D, med, 10);
+  const sil = km.silhouette(D, r.assi, false).sil;
+  const msil = km.medoid_silhouette(D, med, false).sil;
+  check('pammedsil_swap k2: loss', near(r.loss, 0.8805555555555555));
+  check('pammedsil_swap k2: msil', near(msil, 0.8805555555555555));
+  check('pammedsil_swap k2: nSwaps', r.nSwaps === 1);
+  check('pammedsil_swap k2: nIter', r.nIter === 2);
+  check('pammedsil_swap k2: assi', eqArr(r.assi, [0, 0, 0, 1, 1]));
+  check('pammedsil_swap k2: med', eqArr(med, [0, 4]));
+  check('pammedsil_swap k2: sil', near(sil, 0.7522494172494172));
+}
+
+// ============================================================================
+// Silhouette standalone
+// ============================================================================
+{
+  const sil = km.silhouette(D, [0, 0, 0, 1, 1], false).sil;
+  check('silhouette [0,0,0,1,1]', near(sil, 0.7522494172494172));
+}
+{
+  const sil = km.silhouette(D, [0, 0, 2, 1, 1], false).sil;
+  check('silhouette [0,0,2,1,1]', near(sil, 0.5622222222222222));
+}
+
+// ============================================================================
+// DynMSC (2D dense arrays; pass a FIXED initial med for determinism)
+// ============================================================================
+{
+  const D4 = [
+    [0, 1, 2, 3],
+    [1, 0, 4, 5],
+    [2, 4, 0, 6],
+    [3, 5, 6, 0],
+  ];
+  const med = [0, 1, 2];
+  const r = km.dynmsc(D4, med, 2, 100);
+  const msil = km.medoid_silhouette(D4, r.meds, false).sil;
+  check('dynmsc D4: loss', near(r.loss, 0.9375));
+  check('dynmsc D4: meds.length', r.meds.length === 3);
+  check('dynmsc D4: msil', near(msil, 0.9375));
+}
+{
+  const D5 = [
+    [0, 1, 2, 3, 1],
+    [1, 0, 4, 5, 2],
+    [2, 4, 0, 6, 3],
+    [3, 5, 6, 0, 4],
+    [2, 1, 5, 6, 5],
+  ];
+  const med = [0, 1, 2];
+  const r = km.dynmsc(D5, med, 1, 100);
+  const msil = km.medoid_silhouette(D5, r.meds, false).sil;
+  check('dynmsc D5: loss', near(r.loss, 0.87));
+  check('dynmsc D5: meds.length', r.meds.length === 3);
+  check('dynmsc D5: msil', near(msil, 0.87));
+}
+
+// ============================================================================
+// RNG-dependent (assert only invariants; JS PRNG != Rust StdRng)
+// ============================================================================
+{
+  const med = [0, 1];
+  const r = km.rand_fasterpam(D, med, 10);
+  check('rand_fasterpam: loss near 4', near(r.loss, 4));
+}
+{
+  const med = [0, 1];
+  const r = km.par_fasterpam(D, med, 10);
+  check('par_fasterpam: loss near 4', near(r.loss, 4));
+}
+
+// ============================================================================
+// Summary
+// ============================================================================
+console.log('');
+console.log(`Summary: ${passed} passed, ${failed} failed`);
+process.exit(failed > 0 ? 1 : 0);

package/src/k-medoids/util.mjs

@@ -0,0 +1,63 @@
+// Utility types and helpers, ported from src/util.rs
+export const U32_MAX = 4294967295;
+export const USIZE_MAX = Number.MAX_SAFE_INTEGER;
+
+/** Object id (i) and distance (d) pair. */
+export class DistancePair {
+  constructor(i, d) { this.i = i; this.d = d; }
+  clone() { return new DistancePair(this.i, this.d); }
+  static empty() { return new DistancePair(U32_MAX, 0); }
+}
+
+/** Per-point record: nearest + second nearest medoid. */
+export class Rec {
+  constructor(i1, d1, i2, d2) { this.near = new DistancePair(i1, d1); this.seco = new DistancePair(i2, d2); }
+  clone() { return new Rec(this.near.i, this.near.d, this.seco.i, this.seco.d); }
+  static empty() { return new Rec(U32_MAX, 0, U32_MAX, 0); }
+}
+
+/** Per-point record: nearest + second + third nearest medoid. */
+export class Reco {
+  constructor(i1, d1, i2, d2, i3, d3) {
+    this.near = new DistancePair(i1, d1);
+    this.seco = new DistancePair(i2, d2);
+    this.third = new DistancePair(i3, d3);
+  }
+  clone() { return new Reco(this.near.i, this.near.d, this.seco.i, this.seco.d, this.third.i, this.third.d); }
+  static empty() { return new Reco(U32_MAX, 0, U32_MAX, 0, U32_MAX, 0); }
+}
+
+/** Find the minimum (index and value) over an array of numbers. */
+export function find_min(arr) {
+  let bi = 0, bv = arr[0];
+  for (let i = 1; i < arr.length; i++) { if (arr[i] < bv) { bi = i; bv = arr[i]; } }
+  return [bi, bv];
+}
+
+/** Find the maximum (index and value) over an array of numbers. */
+export function find_max(arr) {
+  let bi = 0, bv = arr[0];
+  for (let i = 1; i < arr.length; i++) { if (arr[i] > bv) { bi = i; bv = arr[i]; } }
+  return [bi, bv];
+}
+
+/** Choose the best medoid within a partition. Mutates med[m]. Returns [changed, sumb]. */
+export function choose_medoid_within_partition(mat, assi, med, m) {
+  const first = med[m];
+  let best = first;
+  let sumb = 0;
+  for (let i = 0; i < assi.length; i++) {
+    if (first !== i && assi[i] === m) sumb += mat.get(first, i);
+  }
+  for (let j = 0; j < assi.length; j++) {
+    if (j !== first && assi[j] === m) {
+      let sumj = 0;
+      for (let i = 0; i < assi.length; i++) {
+        if (i !== j && assi[i] === m) sumj += mat.get(j, i);
+      }
+      if (sumj < sumb) { best = j; sumb = sumj; }
+    }
+  }
+  med[m] = best;
+  return [best !== first, sumb];
+}

package/test/jaccardBitset.test.mjs

@@ -0,0 +1,141 @@
+import assert from 'assert'
+import WCluster from '../src/WCluster.mjs'
+import { jaccardBitset, packBits, jaccardBits } from '../src/jaccardBitset.mjs'
+
+
+//確定性PRNG(mulberry32), 使測試資料可重現
+function mulberry32(a) {
+    return function() {
+        a |= 0
+        a = a + 0x6D2B79F5 | 0
+        let t = Math.imul(a ^ a >>> 15, 1 | a)
+        t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t
+        return ((t ^ t >>> 14) >>> 0) / 4294967296
+    }
+}
+
+//逐維Jaccard(0/1陣列), 作為對照基準
+function jacNaive(a, b) {
+    let inter = 0
+    let uni = 0
+    for (let k = 0; k < a.length; k++) {
+        let x = a[k]
+        let y = b[k]
+        if (x & y) inter++
+        if (x | y) uni++
+    }
+    return uni === 0 ? 0 : 1 - inter / uni
+}
+
+//產生G個分離良好的二元blob(交錯排列), 回傳{data, truth}
+function genBinaryBlobs(G, m, D, active, flips, seed) {
+    let rnd = mulberry32(seed)
+    let bases = []
+    for (let g = 0; g < G; g++) {
+        let base = new Array(D).fill(0)
+        let s = new Set()
+        while (s.size < active) {
+            s.add(Math.floor(rnd() * D))
+        }
+        s.forEach((i) => {
+            base[i] = 1
+        })
+        bases.push(base)
+    }
+    let data = []
+    let truth = []
+    for (let i = 0; i < m; i++) {
+        for (let g = 0; g < G; g++) {
+            let v = bases[g].slice()
+            for (let f = 0; f < flips; f++) {
+                let p = Math.floor(rnd() * D)
+                v[p] = v[p] ? 0 : 1
+            }
+            data.push(v)
+            truth.push(g)
+        }
+    }
+    return { data, truth }
+}
+
+//cluster purity(各分群以多數ground-truth標籤計, 全對為1)
+function purity(ginds, truth) {
+    let correct = 0
+    for (let g of ginds) {
+        let cnt = {}
+        for (let i of g) {
+            cnt[truth[i]] = (cnt[truth[i]] || 0) + 1
+        }
+        correct += Math.max(...Object.values(cnt))
+    }
+    return correct / truth.length
+}
+
+//flat是否恰好涵蓋0..n-1各一次
+function coversAll(ginds, n) {
+    let flat = ginds.flat().sort((a, b) => a - b)
+    if (flat.length !== n) {
+        return false
+    }
+    for (let i = 0; i < n; i++) {
+        if (flat[i] !== i) {
+            return false
+        }
+    }
+    return true
+}
+
+
+describe(`jaccardBitset`, function() {
+
+    this.timeout(60000)
+
+    it(`jaccardBits 對已知小案例正確`, function() {
+        //a=[1,1,0,0], b=[1,0,1,0] → 交集1, 聯集3 → 1-1/3
+        assert.strict.strictEqual(jaccardBits(packBits([1, 1, 0, 0]), packBits([1, 0, 1, 0])), 1 - 1 / 3)
+        //相同列 → 0
+        assert.strict.strictEqual(jaccardBits(packBits([1, 0, 1]), packBits([1, 0, 1])), 0)
+        //兩列全0(聯集0) → 視為相同 0
+        assert.strict.strictEqual(jaccardBits(packBits([0, 0, 0]), packBits([0, 0, 0])), 0)
+        //完全不相交 → 1
+        assert.strict.strictEqual(jaccardBits(packBits([1, 0]), packBits([0, 1])), 1)
+    })
+
+    it(`jaccardBits 與逐維Jaccard對隨機二元向量數值一致(含D非32倍數)`, function() {
+        let rnd = mulberry32(123)
+        let allEqual = true
+        for (let D of [16, 33, 50, 64, 100, 200]) {
+            let rows = Array.from({ length: 12 }, () => Array.from({ length: D }, () => (rnd() < 0.3 ? 1 : 0)))
+            for (let i = 0; i < rows.length; i++) {
+                for (let j = i + 1; j < rows.length; j++) {
+                    let a = jaccardBits(packBits(rows[i]), packBits(rows[j]))
+                    let b = jacNaive(rows[i], rows[j])
+                    if (Math.abs(a - b) > 1e-12) {
+                        allEqual = false
+                    }
+                }
+            }
+        }
+        assert.strict.strictEqual(allEqual, true)
+    })
+
+    it(`經 WCluster.cluster: helper(fasterPAM) ginds 與逐維版完全相同`, async function() {
+        let { data: rows } = genBinaryBlobs(6, 40, 300, 45, 6, 42)
+        let rNaive = await WCluster.cluster(rows, { mode: 'k-medoids', kNumber: 6, usePCA: false, funDist: jacNaive, useMethod: 'fasterPAM' })
+        let { data, funDist } = jaccardBitset(rows)
+        let rBits = await WCluster.cluster(data, { mode: 'k-medoids', kNumber: 6, usePCA: false, funDist, useMethod: 'fasterPAM' })
+        assert.strict.deepStrictEqual(rBits.ginds, rNaive.ginds)
+    })
+
+    it(`helper 在分離良好的二元blob上 purity=1 且涵蓋全部 index`, async function() {
+        let G = 6
+        let m = 40
+        let n = G * m
+        let { data: rows, truth } = genBinaryBlobs(G, m, 300, 45, 6, 42)
+        let { data, funDist } = jaccardBitset(rows)
+        let r = await WCluster.cluster(data, { mode: 'k-medoids', kNumber: G, usePCA: false, funDist, useMethod: 'fasterPAM' })
+        assert.strict.strictEqual(coversAll(r.ginds, n), true)
+        assert.strict.strictEqual(purity(r.ginds, truth), 1)
+    })
+
+})