w-cluster 1.0.19 → 1.0.21

package/src/k-medoids/fasterpam.mjs

@@ -0,0 +1,233 @@
+// FasterPAM algorithm, ported 1:1 from src/fasterpam.rs
+import { arrayAdapter } from './arrayadapter.mjs';
+import { Rec, DistancePair, U32_MAX, find_min, choose_medoid_within_partition } from './util.mjs';
+import { shuffle } from './initialization.mjs';
+
+/**
+ * Run the FasterPAM algorithm.
+ *
+ * If used multiple times, it is better to additionally shuffle the input data,
+ * to increase randomness of the solutions found and hence increase the chance
+ * of finding a better solution.
+ *
+ * @param mat - a pairwise distance matrix
+ * @param med - the list of medoids (mutated in place)
+ * @param maxiter - the maximum number of iterations allowed
+ * @returns { loss, assi, nIter, nSwaps }
+ *
+ * Panics (throws) when the dissimilarity matrix is not square, or k is 0 or larger than N.
+ */
+export function fasterpam(mat, med, maxiter) {
+  mat = arrayAdapter(mat);
+  const n = mat.len(), k = med.length;
+  if (k === 1) {
+    const assi = new Array(n).fill(0);
+    const [swapped, loss] = choose_medoid_within_partition(mat, assi, med, 0);
+    return { loss, assi, nIter: 1, nSwaps: swapped ? 1 : 0 };
+  }
+  let [loss, data] = initial_assignment(mat, med);
+  let removal_loss = new Array(k).fill(0);
+  update_removal_loss(data, removal_loss);
+  let lastswap = n, n_swaps = 0, iter = 0;
+  while (iter < maxiter) {
+    iter += 1;
+    const swaps_before = n_swaps, lastloss = loss;
+    for (let j = 0; j < n; j++) {
+      if (j === lastswap) {
+        break;
+      }
+      if (j === med[data[j].near.i]) {
+        continue; // This already is a medoid
+      }
+      const [change, b] = find_best_swap(mat, removal_loss, data, j);
+      if (change >= 0) {
+        continue; // No improvement
+      }
+      n_swaps += 1;
+      lastswap = j;
+      // perform the swap
+      loss = do_swap(mat, med, data, b, j);
+      update_removal_loss(data, removal_loss);
+    }
+    if (n_swaps === swaps_before || loss >= lastloss) {
+      break; // converged
+    }
+  }
+  const assi = data.map((x) => x.near.i);
+  return { loss, assi, nIter: iter, nSwaps: n_swaps };
+}
+
+/**
+ * Run the FasterPAM algorithm with additional randomization.
+ *
+ * This increases the chance of finding a better solution when used multiple times,
+ * as it decreases the dependency on the input data order.
+ *
+ * @param mat - a pairwise distance matrix
+ * @param med - the list of medoids (mutated in place)
+ * @param maxiter - the maximum number of iterations allowed
+ * @param rng - random number generator for shuffling the input data
+ * @returns { loss, assi, nIter, nSwaps }
+ */
+export function rand_fasterpam(mat, med, maxiter, rng = Math.random) {
+  mat = arrayAdapter(mat);
+  const n = mat.len(), k = med.length;
+  if (k === 1) {
+    const assi = new Array(n).fill(0);
+    const [swapped, loss] = choose_medoid_within_partition(mat, assi, med, 0);
+    return { loss, assi, nIter: 1, nSwaps: swapped ? 1 : 0 };
+  }
+  let [loss, data] = initial_assignment(mat, med);
+
+  let removal_loss = new Array(k).fill(0);
+  update_removal_loss(data, removal_loss);
+  let lastswap = n, n_swaps = 0, iter = 0;
+  const seq = shuffle(rng, n); // random shuffling
+  while (iter < maxiter) {
+    iter += 1;
+    const swaps_before = n_swaps, lastloss = loss;
+    for (const j of seq) {
+      if (j === lastswap) {
+        break;
+      }
+      if (j === med[data[j].near.i]) {
+        continue; // This already is a medoid
+      }
+      const [change, b] = find_best_swap(mat, removal_loss, data, j);
+      if (change >= 0) {
+        continue; // No improvement
+      }
+      n_swaps += 1;
+      lastswap = j;
+      // perform the swap
+      loss = do_swap(mat, med, data, b, j);
+      update_removal_loss(data, removal_loss);
+    }
+    if (n_swaps === swaps_before || loss >= lastloss) {
+      break; // converged
+    }
+  }
+  const assi = data.map((x) => x.near.i);
+  return { loss, assi, nIter: iter, nSwaps: n_swaps };
+}
+
+/** Perform the initial assignment to medoids. Returns [loss, data] with data = Rec[]. */
+export function initial_assignment(mat, med) {
+  const n = mat.len(), k = med.length;
+  if (!mat.isSquare()) throw new Error('Dissimilarity matrix is not square');
+  if (!(n <= U32_MAX)) throw new Error('N is too large');
+  if (!(k > 0 && k < U32_MAX)) throw new Error('invalid N');
+  if (!(k <= n)) throw new Error('k must be at most N');
+  const data = Array.from({ length: mat.len() }, () => Rec.empty());
+
+  const firstcenter = med[0];
+  let loss = 0;
+  for (let i = 0; i < data.length; i++) {
+    // *cur = Rec::new(...): overwrite the slot with a fresh Rec, then mutate it
+    data[i] = new Rec(0, mat.get(i, firstcenter), U32_MAX, 0);
+    const curRec = data[i];
+    for (let m = 1; m < med.length; m++) {
+      const me = med[m];
+      const d = mat.get(i, me);
+      if (d < curRec.near.d || i === me) {
+        curRec.seco = curRec.near.clone();
+        curRec.near = new DistancePair(m, d);
+      } else if (curRec.seco.i === U32_MAX || d < curRec.seco.d) {
+        curRec.seco = new DistancePair(m, d);
+      }
+    }
+    loss += curRec.near.d;
+  }
+  return [loss, data];
+}
+
+/** Find the best swap for object j - FastPAM version. Returns [change, b]. */
+export function find_best_swap(mat, removal_loss, data, j) {
+  const ploss = removal_loss.slice();
+  // Improvement from the journal version:
+  let acc = 0;
+  for (let o = 0; o < data.length; o++) {
+    const reco = data[o];
+    const doj = mat.get(o, j);
+    // New medoid is closest:
+    if (doj < reco.near.d) {
+      acc += doj - reco.near.d;
+      // loss already includes ds - dn, remove
+      ploss[reco.near.i] += reco.near.d - reco.seco.d;
+    } else if (doj < reco.seco.d) {
+      // loss already includes ds - dn, adjust to d(xo) - dn
+      ploss[reco.near.i] += doj - reco.seco.d;
+    }
+  }
+  const [b, bloss] = find_min(ploss);
+  return [bloss + acc, b]; // add the shared accumulator
+}
+
+/** Update the loss when removing each medoid. Mutates lossArr. */
+export function update_removal_loss(data, loss) {
+  loss.fill(0); // stable since 1.50
+  for (let r = 0; r < data.length; r++) {
+    const rec = data[r];
+    loss[rec.near.i] += rec.seco.d - rec.near.d;
+    // as N might be unsigned
+  }
+}
+
+/** Update the second nearest medoid information. Called after each swap. Returns a fresh DistancePair. */
+export function update_second_nearest(mat, med, n, b, o, doj) {
+  let s = new DistancePair(b, doj);
+  for (let i = 0; i < med.length; i++) {
+    const mi = med[i];
+    if (i === n || i === b) {
+      continue;
+    }
+    const d = mat.get(o, mi);
+    if (d < s.d) {
+      s = new DistancePair(i, d);
+    }
+  }
+  return s;
+}
+
+/** Perform a single swap. Returns the RAW summed loss (sum of near.d). */
+export function do_swap(mat, med, data, b, j) {
+  const n = mat.len();
+  if (!(b < med.length)) throw new Error('invalid medoid number');
+  if (!(j < n)) throw new Error('invalid object number');
+  med[b] = j;
+  let acc = 0;
+  for (let o = 0; o < data.length; o++) {
+    const reco = data[o];
+    if (o === j) {
+      if (reco.near.i !== b) {
+        reco.seco = reco.near.clone();
+      }
+      reco.near = new DistancePair(b, 0);
+      acc += 0;
+      continue;
+    }
+    const doj = mat.get(o, j);
+    // Nearest medoid is gone:
+    if (reco.near.i === b) {
+      if (doj < reco.seco.d) {
+        reco.near = new DistancePair(b, doj);
+      } else {
+        reco.near = reco.seco.clone();
+        reco.seco = update_second_nearest(mat, med, reco.near.i, b, o, doj);
+      }
+    } else {
+      // nearest not removed
+      if (doj < reco.near.d) {
+        reco.seco = reco.near.clone();
+        reco.near = new DistancePair(b, doj);
+      } else if (doj < reco.seco.d) {
+        reco.seco = new DistancePair(b, doj);
+      } else if (reco.seco.i === b) {
+        // second nearest was replaced
+        reco.seco = update_second_nearest(mat, med, reco.near.i, b, o, doj);
+      }
+    }
+    acc += reco.near.d;
+  }
+  return acc;
+}

package/src/k-medoids/fastmsc.mjs

@@ -0,0 +1,94 @@
+// Ported 1:1 from src/fastmsc.rs (FastMSC algorithm).
+import { arrayAdapter } from './arrayadapter.mjs';
+import { USIZE_MAX, choose_medoid_within_partition } from './util.mjs';
+import { initial_assignment, update_removal_loss, find_best_swap, do_swap, initial_assignment_k2, find_best_swap_k2, do_swap_k2 } from './fastermsc.mjs';
+
+/**
+ * Run the FastMSC algorithm, which yields the same results as the original PAMMEDSIL.
+ *
+ * This is faster than PAMMEDSIL, but slower than FasterMSC, and mostly of interest for academic reasons.
+ * This is the improved version, which costs O(n^2) per iteration to find the best swap.
+ *
+ * @param {object} mat - a pairwise distance matrix
+ * @param {number[]} med - the list of medoids (mutated in place)
+ * @param {number} maxiter - the maximum number of iterations allowed
+ * returns { loss, assi, nIter, nSwaps }
+ */
+export function fastmsc(mat, med, maxiter) {
+  mat = arrayAdapter(mat);
+  const n = mat.len(), k = med.length;
+  if (k === 1) {
+    const assi = new Array(n).fill(0);
+    const [swapped, loss] = choose_medoid_within_partition(mat, assi, med, 0);
+    return { loss, assi, nIter: 1, nSwaps: swapped ? 1 : 0 };
+  }
+  if (k === 2) { // special hadling, as there is no third
+    return fastmsc_k2(mat, med, maxiter);
+  }
+  let [loss, data] = initial_assignment(mat, med);
+
+  let removal_loss = new Array(k).fill(0);
+  let n_swaps = 0, iter = 0;
+  while (iter < maxiter) {
+    iter += 1;
+    let best = [0, USIZE_MAX, USIZE_MAX];
+    update_removal_loss(data, removal_loss);
+    for (let j = 0; j < n; j++) {
+      if (j === med[data[j].near.i]) {
+        continue; // This already is a medoid
+      }
+      const [change, b] = find_best_swap(mat, removal_loss, data, j);
+      if (change <= best[0]) {
+        continue; // No improvement
+      }
+      best = [change, b, j];
+    }
+    if (best[0] > 0) {
+      n_swaps += 1;
+      // perform the swap
+      const newloss = do_swap(mat, med, data, best[1], best[2]);
+      if (newloss >= loss) {
+        break; // Probably numerically unstable now.
+      }
+      loss = newloss;
+    } else {
+      break; // No improvement, or NaN.
+    }
+  }
+  const assi = data.map((x) => x.near.i);
+  loss = 1 - loss / n;
+  return { loss, assi, nIter: iter, nSwaps: n_swaps };
+}
+
+/** Special case k=2 of the FastMSC algorithm. */
+function fastmsc_k2(mat, med, maxiter) {
+  const n = mat.len(), k = med.length;
+  if (!(k === 2)) throw new Error('Only valid for k=2');
+  let [loss, assi, data] = initial_assignment_k2(mat, med);
+  let n_swaps = 0, iter = 0;
+  while (iter < maxiter) {
+    iter += 1;
+    let best = [0, k, USIZE_MAX];
+    for (let j = 0; j < n; j++) {
+      if (j === med[assi[j]]) {
+        continue; // This already is a medoid
+      }
+      const [newloss, b] = find_best_swap_k2(mat, data, j); // assi not used, see below
+      if (best[2] === USIZE_MAX || newloss < best[0]) {
+        best = [newloss, b, j];
+      }
+    }
+    if (!(best[0] < loss)) {
+      break; // No improvement
+    }
+    // perform the swap
+    n_swaps += 1;
+    const newloss = do_swap_k2(mat, med, assi, data, best[1], best[2]);
+    if (!(newloss < loss)) {
+      break; // Probably numerically unstable
+    }
+    loss = newloss;
+  }
+  loss = 1 - loss / n;
+  return { loss, assi, nIter: iter, nSwaps: n_swaps };
+}

package/src/k-medoids/fastpam1.mjs

@@ -0,0 +1,60 @@
+import { arrayAdapter } from './arrayadapter.mjs';
+import { USIZE_MAX, choose_medoid_within_partition } from './util.mjs';
+import { initial_assignment, find_best_swap, do_swap, update_removal_loss } from './fasterpam.mjs';
+
+/**
+ * Run the FastPAM1 algorithm, which yields the same results as the original PAM.
+ *
+ * This is faster than PAM, but slower than FasterPAM, and mostly of interest for academic reasons.
+ * Quality-wise, FasterPAM is not worse on average, but much faster.
+ *
+ * This is the improved version from the journal version of the paper,
+ * which costs O(n²) per iteration to find the best swap.
+ *
+ * @param {object} mat - a pairwise distance matrix (array or wrapped)
+ * @param {number[]} med - the list of medoids (mutated in place)
+ * @param {number} maxiter - the maximum number of iterations allowed
+ * @returns {{ loss: number, assi: number[], nIter: number, nSwaps: number }}
+ */
+export function fastpam1(mat, med, maxiter) {
+	mat = arrayAdapter(mat);
+	const n = mat.len();
+	const k = med.length;
+	if (k === 1) {
+		const assi = new Array(n).fill(0);
+		const [swapped, loss] = choose_medoid_within_partition(mat, assi, med, 0);
+		return { loss, assi, nIter: 1, nSwaps: swapped ? 1 : 0 };
+	}
+	let [loss, data] = initial_assignment(mat, med);
+	const removal_loss = new Array(k).fill(0);
+	let n_swaps = 0;
+	let iter = 0;
+	while (iter < maxiter) {
+		iter += 1;
+		let best = [0, USIZE_MAX, USIZE_MAX];
+		update_removal_loss(data, removal_loss);
+		for (let j = 0; j < n; j++) {
+			if (j === med[data[j].near.i]) {
+				continue; // This already is a medoid
+			}
+			const [change, b] = find_best_swap(mat, removal_loss, data, j);
+			if (change >= best[0]) {
+				continue; // No improvement
+			}
+			best = [change, b, j];
+		}
+		if (best[0] < 0) {
+			n_swaps += 1;
+			// perform the swap
+			const newloss = do_swap(mat, med, data, best[1], best[2]);
+			if (newloss >= loss) {
+				break; // Probably numerically unstable now.
+			}
+			loss = newloss;
+		} else {
+			break; // No improvement, or NaN.
+		}
+	}
+	const assi = data.map(x => x.near.i);
+	return { loss, assi, nIter: iter, nSwaps: n_swaps };
+}

package/src/k-medoids/index.mjs

@@ -0,0 +1,37 @@
+/**
+ * k-Medoids Clustering with the FasterPAM Algorithm
+ *
+ * For details on the implemented FasterPAM algorithm, please see:
+ *
+ * Erich Schubert, Peter J. Rousseeuw
+ * Fast and Eager k-Medoids Clustering:
+ * O(k) Runtime Improvement of the PAM, CLARA, and CLARANS Algorithms
+ * Information Systems (101), 2021, 101804
+ * https://doi.org/10.1016/j.is.2021.101804 (open access)
+ *
+ * Erich Schubert, Peter J. Rousseeuw:
+ * Faster k-Medoids Clustering: Improving the PAM, CLARA, and CLARANS Algorithms
+ * In: 12th International Conference on Similarity Search and Applications (SISAP 2019), 171-187.
+ * https://doi.org/10.1007/978-3-030-32047-8_16
+ * Preprint: https://arxiv.org/abs/1810.05691
+ *
+ * This is a port of the original Java code from ELKI (https://elki-project.github.io/) to Rust,
+ * and subsequently ported to JavaScript.
+ *
+ * If you use this in scientific work, please consider citing above articles.
+ */
+
+export { arrayAdapter, DenseMatrix, LowerTriangle } from './arrayadapter.mjs';
+export { random_initialization, first_k } from './initialization.mjs';
+export { fasterpam, rand_fasterpam } from './fasterpam.mjs';
+export { fastpam1 } from './fastpam1.mjs';
+export { alternating } from './alternating.mjs';
+export { pam, pam_build, pam_swap } from './pam.mjs';
+export { fastmsc } from './fastmsc.mjs';
+export { fastermsc } from './fastermsc.mjs';
+export { dynmsc } from './dynmsc.mjs';
+export { pamsil, pamsil_swap } from './pamsil.mjs';
+export { pammedsil, pammedsil_swap } from './pammedsil.mjs';
+export { silhouette, medoid_silhouette } from './silhouette.mjs';
+export { par_fasterpam } from './par_fasterpam.mjs';
+export { par_silhouette } from './par_silhouette.mjs';

package/src/k-medoids/initialization.mjs

@@ -0,0 +1,35 @@
+// Initialization helpers, ported from src/initialization.rs (RNG approximated for JS)
+
+/** Use the first k objects (0..k-1) as initial medoids. */
+export function first_k(k) {
+  return Array.from({ length: k }, (_, i) => i);
+}
+
+/** Sample k DISTINCT indices from [0, n) using Floyd's algorithm. rng: () => float in [0,1). */
+export function sample(rng, n, k) {
+  if (k > n) throw new Error('`amount` of samples must be less than or equal to `length`');
+  const chosen = new Set();
+  const res = [];
+  for (let j = n - k; j < n; j++) {
+    const t = Math.floor(rng() * (j + 1)); // 0..j inclusive
+    const v = chosen.has(t) ? j : t;
+    chosen.add(v);
+    res.push(v);
+  }
+  return res;
+}
+
+/** Random initialization: k distinct medoid indices in [0, n). */
+export function random_initialization(n, k, rng = Math.random) {
+  return sample(rng, n, k);
+}
+
+/** Fisher-Yates shuffle of [0, n). Used by rand_fasterpam / par_fasterpam. */
+export function shuffle(rng, n) {
+  const a = Array.from({ length: n }, (_, i) => i);
+  for (let i = n - 1; i > 0; i--) {
+    const j = Math.floor(rng() * (i + 1));
+    const tmp = a[i]; a[i] = a[j]; a[j] = tmp;
+  }
+  return a;
+}

package/src/k-medoids/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "k-medoids",
+  "version": "0.5.5",
+  "description": "k-Medoids clustering (FasterPAM, FasterMSC, DynMSC, PAM, ...) ported from rust-kmedoids",
+  "type": "module",
+  "main": "index.mjs",
+  "license": "GPL-3.0-or-later"
+}

package/src/k-medoids/pam.mjs

@@ -0,0 +1,203 @@
+// PAM (BUILD and SWAP) algorithm, ported 1:1 from src/pam.rs
+import { arrayAdapter } from './arrayadapter.mjs';
+import { Rec, DistancePair, U32_MAX, USIZE_MAX, choose_medoid_within_partition } from './util.mjs';
+import { initial_assignment, do_swap } from './fasterpam.mjs';
+
+/**
+ * Run the original PAM SWAP algorithm (no BUILD, but given initial medoids).
+ *
+ * Provided for academic reasons to see the performance difference.
+ *
+ * @param mat - a pairwise distance matrix
+ * @param med - the list of medoids (mutated in place)
+ * @param maxiter - the maximum number of iterations allowed
+ * @returns { loss, assi, nIter, nSwaps }
+ */
+export function pam_swap(mat, med, maxiter) {
+  mat = arrayAdapter(mat);
+  const [loss, data] = initial_assignment(mat, med);
+  const [nloss, assi, nIter, nSwaps] = pam_optimize(mat, med, data, maxiter, loss);
+  return { loss: nloss, assi, nIter, nSwaps };
+}
+
+/**
+ * Run the original PAM BUILD algorithm.
+ *
+ * Provided for academic reasons to see the performance difference.
+ *
+ * @param mat - a pairwise distance matrix
+ * @param k - the number of medoids to pick
+ * @returns { loss, assi, meds }
+ */
+export function pam_build(mat, k) {
+  mat = arrayAdapter(mat);
+  const n = mat.len();
+  if (!mat.isSquare()) throw new Error('Dissimilarity matrix is not square');
+  if (!(n <= U32_MAX)) throw new Error('N is too large');
+  if (!(k > 0 && k < U32_MAX)) throw new Error('invalid N');
+  if (!(k <= n)) throw new Error('k must be at most N');
+  const meds = [];
+  const data = [];
+  const loss = pam_build_initialize(mat, meds, data, k);
+  const assi = data.map((x) => x.near.i);
+  return { loss, assi, meds };
+}
+
+/**
+ * Run the original PAM algorithm (BUILD and SWAP).
+ *
+ * Provided for academic reasons to see the performance difference.
+ *
+ * @param mat - a pairwise distance matrix
+ * @param k - the number of medoids to pick
+ * @param maxiter - the maximum number of iterations allowed
+ * @returns { loss, assi, meds, nIter, nSwaps }
+ */
+export function pam(mat, k, maxiter) {
+  mat = arrayAdapter(mat);
+  const n = mat.len();
+  if (!mat.isSquare()) throw new Error('Dissimilarity matrix is not square');
+  if (!(n <= U32_MAX)) throw new Error('N is too large');
+  if (!(k > 0 && k < U32_MAX)) throw new Error('invalid N');
+  if (!(k <= n)) throw new Error('k must be at most N');
+  const meds = [];
+  const data = [];
+  const loss = pam_build_initialize(mat, meds, data, k);
+  const [nloss, assi, nIter, nSwaps] = pam_optimize(mat, meds, data, maxiter, loss);
+  return { loss: nloss, assi, meds, nIter, nSwaps }; // also return medoids
+}
+
+/** Main optimization function of PAM, not exposed (use pam_swap or pam). Returns [loss, assi, nIter, nSwaps]. */
+function pam_optimize(mat, med, data, maxiter, loss) {
+  const n = mat.len(), k = med.length;
+  if (k === 1) {
+    const assi = new Array(n).fill(0);
+    const [swapped, sloss] = choose_medoid_within_partition(mat, assi, med, 0);
+    return [sloss, assi, 1, swapped ? 1 : 0];
+  }
+  let n_swaps = 0, iter = 0;
+  while (iter < maxiter) {
+    iter += 1;
+    let best = [0, k, USIZE_MAX];
+    for (let j = 0; j < n; j++) {
+      if (j === med[data[j].near.i]) {
+        continue; // This already is a medoid
+      }
+      const [change, b] = find_best_swap_pam(mat, med, data, j);
+      if (change >= best[0]) {
+        continue; // No improvement
+      }
+      best = [change, b, j];
+    }
+    if (best[0] < 0) {
+      n_swaps += 1;
+      // perform the swap
+      const newloss = do_swap(mat, med, data, best[1], best[2]);
+      if (newloss >= loss) {
+        break; // Probably numerically unstable now.
+      }
+      loss = newloss;
+    } else {
+      break; // No improvement, or NaN.
+    }
+  }
+  const assi = data.map((x) => x.near.i);
+  return [loss, assi, iter, n_swaps];
+}
+
+/** Find the best swap for object j - slower PAM version. Returns [acc_best, m_best]. */
+function find_best_swap_pam(mat, med, data, j) {
+  const recj = data[j];
+  let best = [0, USIZE_MAX];
+  for (let m = 0; m < med.length; m++) {
+    let acc = -recj.near.d; // j becomes medoid
+    for (let o = 0; o < data.length; o++) {
+      const reco = data[o];
+      if (o === j) {
+        continue;
+      }
+      const doj = mat.get(o, j);
+      // Current medoid is being replaced:
+      if (reco.near.i === m) {
+        if (doj < reco.seco.d) {
+          // Assign to new medoid:
+          acc += doj - reco.near.d;
+        } else {
+          // Assign to second nearest instead:
+          acc += reco.seco.d - reco.near.d;
+        }
+      } else if (doj < reco.near.d) {
+        // new mediod is closer:
+        acc += doj - reco.near.d;
+      } // else no change
+    }
+    if (acc < best[0]) {
+      best = [acc, m];
+    }
+  }
+  return best;
+}
+
+/** Not exposed. Use pam_build or pam. Pushes into medsArr (numbers) and dataArr (Rec). Returns loss. */
+export function pam_build_initialize(mat, meds, data, k) {
+  const n = mat.len();
+  if (!mat.isSquare()) throw new Error('Dissimilarity matrix is not square');
+  // choose first medoid
+  let best = [0, k];
+  for (let i = 0; i < n; i++) {
+    let sum = 0;
+    for (let j = 0; j < n; j++) {
+      if (j !== i) {
+        sum += mat.get(j, i);
+      }
+    }
+    if (i === 0 || sum < best[0]) {
+      best = [sum, i];
+    }
+  }
+  let loss = best[0];
+  meds.push(best[1]);
+  for (let j = 0; j < n; j++) {
+    data.push(new Rec(0, mat.get(j, best[1]), U32_MAX, 0));
+  }
+  // choose remaining medoids
+  for (let l = 1; l < k; l++) {
+    best = [0, k];
+    for (let i = 0; i < data.length; i++) {
+      let sum = -data[i].near.d;
+      for (let j = 0; j < data.length; j++) {
+        const dj = data[j];
+        if (j !== i) {
+          const d = mat.get(j, i);
+          if (d < dj.near.d) {
+            sum += d - dj.near.d;
+          }
+        }
+      }
+      if (i === 0 || sum < best[0]) {
+        best = [sum, i];
+      }
+    }
+    if (best[0] >= 0) { break; } // No further improvements - duplicates etc.
+    // Update assignments:
+    loss = 0;
+    for (let j = 0; j < data.length; j++) {
+      const recj = data[j];
+      if (j === best[1]) {
+        recj.seco = recj.near.clone();
+        recj.near = new DistancePair(l, 0);
+        continue;
+      }
+      const dj = mat.get(j, best[1]);
+      if (dj < recj.near.d) {
+        recj.seco = recj.near.clone();
+        recj.near = new DistancePair(l, dj);
+      } else if (recj.seco.i === U32_MAX || dj < recj.seco.d) {
+        recj.seco = new DistancePair(l, dj);
+      }
+      loss += recj.near.d;
+    }
+    meds.push(best[1]);
+  }
+  return loss;
+}