w-cluster 1.0.19 → 1.0.21

package/src/k-medoids/pammedsil.mjs

@@ -0,0 +1,235 @@
+// Ported 1:1 from src/pammedsil.rs (PAMMEDSIL algorithm).
+import { arrayAdapter } from './arrayadapter.mjs';
+import { Reco, DistancePair, U32_MAX, USIZE_MAX, choose_medoid_within_partition } from './util.mjs';
+import { _loss, initial_assignment, do_swap } from './fastermsc.mjs';
+
+/**
+ * Run the original PAMMEDSIL SWAP algorithm (no initialization, but given initial medoids).
+ * @param {object} mat - 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 pammedsil_swap(mat, med, maxiter) {
+  mat = arrayAdapter(mat);
+  const [loss, data] = initial_assignment(mat, med);
+  return pammedsil_optimize(mat, med, data, maxiter, loss);
+}
+
+/**
+ * Run the original PAM BUILD algorithm combined with the PAMMEDSIL SWAP.
+ * @param {object} mat - pairwise distance matrix
+ * @param {number} k - the number of medoids to pick
+ * @param {number} maxiter - the maximum number of iterations allowed
+ * returns { loss, assi, meds, nIter, nSwaps }
+ */
+export function pammedsil(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 = pammedsil_build_initialize(mat, meds, data, k);
+  const { loss: nloss, assi, nIter, nSwaps } = pammedsil_optimize(mat, meds, data, maxiter, loss);
+  return { loss: nloss, assi, meds, nIter, nSwaps }; // also return medoids
+}
+
+/** Main optimization function of PAMMEDSIL, not exposed (use pammedsil_swap or pammedsil) */
+function pammedsil_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, lloss] = choose_medoid_within_partition(mat, assi, med, 0);
+    return { loss: lloss, assi, nIter: 1, nSwaps: 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] = (k === 2)
+        ? find_best_swap_pammedsil_k2(mat, med, data, j)
+        : find_best_swap_pammedsil(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);
+  loss = 1 - loss / n;
+  return { loss, assi, nIter: iter, nSwaps: n_swaps };
+}
+
+/** Find the best swap for object j. Returns [change, b]. */
+function find_best_swap_pammedsil(mat, med, data, j) {
+  const recj = data[j];
+  let best = [0, USIZE_MAX];
+  for (let m = 0; m < med.length; m++) {
+    let acc = _loss(recj.near.d, recj.seco.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 += _loss(reco.near.d, reco.seco.d) - _loss(doj, reco.seco.d);
+        } else if (doj < reco.third.d) {
+          // Assign to second nearest instead:
+          acc += _loss(reco.near.d, reco.seco.d) - _loss(reco.seco.d, doj);
+        } else {
+          acc += _loss(reco.near.d, reco.seco.d) - _loss(reco.seco.d, reco.third.d);
+        }
+      } else if (reco.seco.i === m) {
+        if (doj < reco.near.d) {
+          acc += _loss(reco.near.d, reco.seco.d) - _loss(doj, reco.near.d);
+        } else if (doj < reco.third.d) {
+          acc += _loss(reco.near.d, reco.seco.d) - _loss(reco.near.d, doj);
+        } else {
+          acc += _loss(reco.near.d, reco.seco.d) - _loss(reco.near.d, reco.third.d);
+        }
+      } else {
+        if (doj < reco.near.d) {
+          acc += _loss(reco.near.d, reco.seco.d) - _loss(doj, reco.near.d);
+        } else if (doj < reco.seco.d) {
+          acc += _loss(reco.near.d, reco.seco.d) - _loss(reco.near.d, doj);
+        }
+      }
+    }
+    if (acc > best[0]) {
+      best = [acc, m];
+    }
+  }
+  return best;
+}
+
+/** Find the best swap for object j (k=2 variant). Returns [change, b]. */
+function find_best_swap_pammedsil_k2(mat, med, data, j) {
+  const recj = data[j];
+  let best = [0, USIZE_MAX];
+  for (let m = 0; m < med.length; m++) {
+    let acc = _loss(recj.near.d, recj.seco.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 += _loss(reco.near.d, reco.seco.d) - _loss(doj, reco.seco.d);
+        } else {
+          // Assign to second nearest instead:
+          acc += _loss(reco.near.d, reco.seco.d) - _loss(reco.seco.d, doj);
+        }
+      } else if (reco.seco.i === m) {
+        if (doj < reco.near.d) {
+          acc += _loss(reco.near.d, reco.seco.d) - _loss(doj, reco.near.d);
+        } else {
+          acc += _loss(reco.near.d, reco.seco.d) - _loss(reco.near.d, doj);
+        }
+      } else {
+        if (doj < reco.near.d) {
+          acc += _loss(reco.near.d, reco.seco.d) - _loss(doj, reco.near.d);
+        } else if (doj < reco.seco.d) {
+          acc += _loss(reco.near.d, reco.seco.d) - _loss(reco.near.d, doj);
+        }
+      }
+    }
+    if (acc > best[0]) {
+      best = [acc, m];
+    }
+  }
+  return best;
+}
+
+/** Not exposed. Use pammedsil_build or pammedsil. Pushes into meds & data. Returns loss. */
+function pammedsil_build_initialize(mat, meds, data, k) {
+  const n = mat.len();
+  // 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 Reco(0, mat.get(j, best[1]), U32_MAX, 0, U32_MAX, 0));
+  }
+  // choose remaining medoids
+  for (let l = 1; l < k; l++) {
+    best = [0, k];
+    for (let i = 1; i < data.length; i++) {
+      let sum = -data[i].near.d;
+      for (let jj = 0; jj < data.length; jj++) {
+        const dj = data[jj];
+        if (jj !== i) {
+          const d = mat.get(jj, 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 more improvement, duplicates
+    // Update assignments:
+    loss = 0;
+    for (let jj = 0; jj < data.length; jj++) {
+      const recj = data[jj];
+      if (jj === best[1]) {
+        recj.third = recj.seco.clone();
+        recj.seco = recj.near.clone();
+        recj.near = new DistancePair(l, 0);
+      } else {
+        const dj = mat.get(jj, best[1]);
+        if (dj < recj.near.d) {
+          recj.third = recj.seco.clone();
+          recj.seco = recj.near.clone();
+          recj.near = new DistancePair(l, dj);
+        } else if (recj.seco.i === U32_MAX || dj < recj.seco.d) {
+          recj.third = recj.seco.clone();
+          recj.seco = new DistancePair(l, dj);
+        } else if (recj.third.i === U32_MAX || dj < recj.third.d) {
+          recj.third = new DistancePair(l, dj);
+        }
+      }
+      loss += _loss(recj.near.d, recj.seco.d);
+    }
+    meds.push(best[1]);
+  }
+  return loss;
+}

package/src/k-medoids/pamsil.mjs

@@ -0,0 +1,153 @@
+// PAMSIL: PAM combined with direct Silhouette optimization.
+// Ported 1:1 from src/pamsil.rs
+
+import { arrayAdapter } from './arrayadapter.mjs';
+import { USIZE_MAX, choose_medoid_within_partition } from './util.mjs';
+import { assign_nearest } from './alternating.mjs';
+import { silhouette } from './silhouette.mjs';
+
+/**
+ * Run the original PAMSIL SWAP algorithm (no BUILD, but given initial medoids).
+ *
+ * @param {*} 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: number, assi: number[], nIter: number, nSwaps: number }}
+ */
+export function pamsil(mat, k, maxiter) {
+  mat = arrayAdapter(mat);
+  const n = mat.len();
+  if (!mat.isSquare()) throw new Error('Dissimilarity matrix is not square');
+  if (!(n <= 4294967295)) throw new Error('N is too large');
+  if (!(k > 0 && k < 4294967295)) throw new Error('invalid N');
+  if (!(k <= n)) throw new Error('k must be at most N');
+  const meds = [];
+  const assi = new Array(n).fill(0);
+  pamsil_build_initialize(mat, meds, assi, k);
+  const [nloss, n_iter, n_swap] = pamsil_optimize(mat, meds, assi, maxiter);
+  return { loss: nloss, assi, meds, nIter: n_iter, nSwaps: n_swap }; // also return medoids
+}
+
+/**
+ * Run the original PAMSIL SWAP algorithm (no BUILD, but given initial medoids).
+ *
+ * @param {*} 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: number, assi: number[], nIter: number, nSwaps: number }}
+ */
+export function pamsil_swap(mat, med, maxiter) {
+  mat = arrayAdapter(mat);
+  const n = mat.len();
+  const assi = new Array(n).fill(0);
+  assign_nearest(mat, med, assi);
+  const [nloss, n_iter, n_swap] = pamsil_optimize(mat, med, assi, maxiter);
+  return { loss: nloss, assi, nIter: n_iter, nSwaps: n_swap };
+}
+
+/**
+ * Main optimization function of PAMSIL, not exposed (use pamsil_swap or pamsil).
+ * @returns {[number, number, number]} [loss, n_iter, n_swaps]
+ */
+function pamsil_optimize(mat, med, assi, maxiter) {
+  const n = mat.len(), k = med.length;
+  if (k === 1) {
+    const [swapped, loss] = choose_medoid_within_partition(mat, assi, med, 0);
+    return [loss, 1, swapped ? 1 : 0];
+  }
+  let n_swaps = 0, iter = 0;
+  let sil = silhouette(mat, assi, false).sil;
+  while (iter < maxiter) {
+    iter += 1;
+    let best = [0, k, USIZE_MAX];
+    for (let m = 0; m < k; m++) {
+      const medm = med[m]; // preseve previous value
+      for (let j = 0; j < n; j++) {
+        if (j === medm || j === med[assi[j]]) {
+          continue; // This already is a medoid
+        }
+        med[m] = j; // replace
+        assign_nearest(mat, med, assi);
+        const siltemp = silhouette(mat, assi, false).sil;
+        if (siltemp <= best[0]) {
+          continue; // No improvement
+        }
+        best = [siltemp, m, j];
+      }
+      med[m] = medm; // restore
+    }
+    if (best[0] <= sil) {
+      break; // no improvement
+    }
+    n_swaps += 1;
+    med[best[1]] = best[2];
+    sil = best[0];
+  }
+  assign_nearest(mat, med, assi);
+  return [sil, iter, n_swaps];
+}
+
+/**
+ * Not exposed. Use pamsil_build or pamsil.
+ * Standard PAM BUILD storing nearest distance per point in a plain number array `data`.
+ * @returns {number} loss
+ */
+function pamsil_build_initialize(mat, meds, assi, k) {
+  const n = mat.len();
+  // 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]);
+  const data = [];
+  assi.fill(0);
+  for (let j = 0; j < n; j++) {
+    data.push(mat.get(j, best[1]));
+  }
+  // choose remaining medoids
+  for (let _ = 1; _ < k; _++) {
+    best = [0, k];
+    for (let i = 0; i < data.length; i++) {
+      const di = data[i];
+      let sum = -di;
+      for (let j = 0; j < data.length; j++) {
+        const dnear = data[j];
+        if (j !== i) {
+          const d = mat.get(j, i);
+          if (d < dnear) {
+            sum += d - dnear;
+          }
+        }
+      }
+      if (i === 0 || sum < best[0]) {
+        best = [sum, i];
+      }
+    }
+    if (!(best[0] <= 0)) throw new Error('assertion failed: best.0 <= L::zero()');
+    // Update assignments:
+    loss = 0;
+    for (let j = 0; j < data.length; j++) {
+      if (j === best[1]) {
+        data[j] = 0;
+        continue;
+      }
+      const dj = mat.get(j, best[1]);
+      if (dj < data[j]) {
+        data[j] = dj;
+      }
+      loss += data[j];
+    }
+    meds.push(best[1]);
+  }
+  return loss;
+}

package/src/k-medoids/par_fasterpam.mjs

@@ -0,0 +1,62 @@
+// Parallel FasterPAM algorithm, ported 1:1 from src/par_fasterpam.rs
+// JS is single-threaded; parallelism is collapsed to a sequential equivalent
+// by delegating to fasterpam.mjs helpers (result-identical to the Rust parallel internals).
+import { arrayAdapter } from './arrayadapter.mjs';
+import { choose_medoid_within_partition } from './util.mjs';
+import { initial_assignment, find_best_swap, do_swap, update_removal_loss } from './fasterpam.mjs';
+import { shuffle } from './initialization.mjs';
+
+/**
+ * Run the FasterPAM algorithm (parallel version).
+ *
+ * For small data sets (n<1000) it is usually faster to use the non-parallel version.
+ *
+ * @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 }
+ *
+ * Panics (throws) when the dissimilarity matrix is not square, or k is 0 or larger than N.
+ */
+export function par_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 };
+}

package/src/k-medoids/par_silhouette.mjs

@@ -0,0 +1,54 @@
+// Parallelism (rayon) collapsed to sequential equivalent for JS.
+import { arrayAdapter } from './arrayadapter.mjs';
+import { checked_div } from './silhouette.mjs';
+
+/**
+ * Compute the Silhouette of a strict partitional clustering (sequential JS port of parallel Rust impl).
+ *
+ * @param {object|Array} mat - pairwise distance matrix (will be wrapped by arrayAdapter)
+ * @param {number[]} assi - cluster assignment for each point
+ * @returns {number} the average silhouette value
+ */
+export function par_silhouette(mat, assi) {
+  mat = arrayAdapter(mat);
+  if (!mat.isSquare()) throw new Error('Dissimilarity matrix is not square');
+  let lsum = 0;
+  for (let i = 0; i < assi.length; i++) {
+    const ai = assi[i];
+    // buf[c] = [count, sum] for cluster c
+    const buf = [];
+    for (let j = 0; j < assi.length; j++) {
+      const aj = assi[j];
+      while (aj >= buf.length) {
+        buf.push([0, 0]);
+      }
+      if (i !== j) {
+        buf[aj][0] += 1;
+        buf[aj][1] += mat.get(i, j);
+      }
+    }
+    if (buf[ai][0] > 0) {
+      const a = checked_div(buf[ai][1], buf[ai][0]);
+      // find minimum average distance to any other cluster (b)
+      // mirrors Rust: tmp.next().unwrap_or_else(L::zero) seeds the fold
+      let tmp2 = 0;
+      let foundFirst = false;
+      let b = 0;
+      for (let c = 0; c < buf.length; c++) {
+        if (c === ai) continue;
+        const avg = checked_div(buf[c][1], buf[c][0]);
+        if (!foundFirst) {
+          tmp2 = avg;
+          foundFirst = true;
+          b = tmp2;
+        } else {
+          b = avg < b ? avg : b;
+        }
+      }
+      // if no other cluster exists, foundFirst is false → b = tmp2 = 0
+      lsum += checked_div(b - a, a > b ? a : b);
+    }
+    // else: singleton, contributes 0 (lsum unchanged)
+  }
+  return lsum / assi.length;
+}

package/src/k-medoids/silhouette.mjs

@@ -0,0 +1,121 @@
+// Silhouette evaluation measures, ported from src/silhouette.rs
+import { arrayAdapter } from './arrayadapter.mjs';
+
+/**
+ * Compute the Silhouette of a strict partitional clustering.
+ *
+ * The Silhouette, proposed by Peter Rousseeuw in 1987, is a popular internal
+ * evaluation measure for clusterings.
+ *
+ * @param mat - a pairwise distance matrix
+ * @param assi - the cluster assignment
+ * @param samples - whether to keep the individual samples, or not
+ * @returns { sil, samples } where sil is the average silhouette and samples are
+ *          the individual silhouette values (empty [] if samples = false)
+ */
+export function silhouette(mat, assi, samples = false) {
+  mat = arrayAdapter(mat);
+  if (!mat.isSquare()) throw new Error('Dissimilarity matrix is not square');
+  let sil = new Array(samples ? assi.length : 0).fill(0);
+  let lsum = 0;
+  let buf = []; // array of [count(u32), sum(L)] pairs
+  for (let i = 0; i < assi.length; i++) {
+    const ai = assi[i];
+    buf.length = 0;
+    for (let j = 0; j < assi.length; j++) {
+      const aj = assi[j];
+      while (aj >= buf.length) {
+        buf.push([0, 0]);
+      }
+      if (i !== j) {
+        buf[aj][0] += 1;
+        buf[aj][1] += mat.get(i, j);
+      }
+    }
+    if (buf.length === 1) {
+      return { sil: 0, samples: sil };
+    }
+    let s;
+    if (buf[ai][0] > 0) {
+      const a = checked_div(buf[ai][1], buf[ai][0]);
+      // Ugly hack to get the min():
+      let started = false;
+      let b = 0;
+      for (let k = 0; k < buf.length; k++) {
+        if (k === ai) continue;
+        const p = buf[k];
+        const y = checked_div(p[1], p[0]);
+        if (!started) {
+          b = y; // tmp.next().unwrap_or_else(L::zero)
+          started = true;
+        } else {
+          b = y < b ? y : b; // tmp.fold(tmp2, |x, y| if y < x { y } else { x })
+        }
+      }
+      // tmp2 = tmp.next().unwrap_or_else(L::zero): if no element, b stays 0
+      s = checked_div(b - a, a > b ? a : b);
+    } else {
+      s = 0; // singleton
+    }
+    if (samples) {
+      sil[i] = s;
+    }
+    lsum += s;
+  }
+  return { sil: lsum / assi.length, samples: sil };
+}
+
+/**
+ * Compute the Medoid Silhouette of a clustering.
+ *
+ * The Medoid Silhouette is an approximation to the original Silhouette where the
+ * distance to the cluster medoid is used instead of the average distance.
+ *
+ * @param mat - a pairwise distance matrix
+ * @param meds - the medoid list
+ * @param samples - whether to keep the individual samples, or not
+ * @returns { sil, samples } where sil is the average medoid silhouette and
+ *          samples are the individual values (empty [] if samples = false)
+ */
+export function medoid_silhouette(mat, meds, samples = false) {
+  mat = arrayAdapter(mat);
+  const n = mat.len(), k = meds.length;
+  if (!mat.isSquare()) throw new Error('Dissimilarity matrix is not square');
+  if (!(n <= U32_MAX_GUARD)) throw new Error('N is too large');
+  let sil = new Array(samples ? n : 0).fill(1);
+  if (k === 1) { return { sil: 1, samples: sil }; } // not really well-defined
+  if (!(k >= 2 && k <= n)) throw new Error('invalid k, must be over 1 and at most N');
+  let loss = 0;
+  for (let i = 0; i < n; i++) {
+    const d1 = mat.get(i, meds[0]), d2 = mat.get(i, meds[1]);
+    let best = d1 < d2 ? [d1, d2] : [d2, d1];
+    for (let s2 = 2; s2 < meds.length; s2++) {
+      const m = meds[s2];
+      const d = mat.get(i, m);
+      if (d < best[0]) {
+        best = [d, best[0]];
+      } else if (d < best[1]) {
+        best = [best[0], d];
+      }
+    }
+    if (best[0] !== 0) {
+      const s = best[0] / best[1];
+      if (samples) { sil[i] = 1 - s; }
+      loss += s;
+    }
+  }
+  loss = 1 - loss / n;
+  return { sil: loss, samples: sil };
+}
+
+// u32::MAX, used only for the "N is too large" assertion.
+const U32_MAX_GUARD = 4294967295;
+
+// helper function, returns 0 on division by 0
+export function checked_div(x, y) {
+  if (y > 0) {
+    return x / y;
+  } else {
+    return 0;
+  }
+}