ckmeans 2.0.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d63d8f65d386bf27082e0a65b1ea82a7d150394b1424ab5c2c274e139f91482
-  data.tar.gz: 1f3c4e91fcc9f3bda3d83521cac164ff83e3e5095705cd15420c6278635fc266
+  metadata.gz: 231337d4b73a838b8a9326936c4ae4c003db103108b6622c22a09a6a44bf4e31
+  data.tar.gz: c0d97cd2fd4b1fd6693305900e9e329e218993fb735b9d24cd1c7281eda14e8a
 SHA512:
-  metadata.gz: 0101cd5f6d5ba925d8f37cc73416008ace4ffce7ea33a437e0189549ede4cbc23b7284de2fe28af181ddf08396b74225c67626e94ce015d54ac14fde17b53bda
-  data.tar.gz: abbcc012e9378ea1fbf15566fd47691bd4cecaaeaf95947c45414dfb7b304db87d803120749aab3ccbf806ab90dd554cce2461f340c348e4f1b820f47be421a2
+  metadata.gz: 04be90532ac9498a184025d849b14a0d34fb61d00352c818a6e7495ae753666689ecef0d542fc6e95f118e5c83fcc29560baee2b339762158d47811a1d4164cd
+  data.tar.gz: '019cc8ff7f3fa2648faa03997fc88489718e944d13760b1e28eed3c4e48d48da56fd87ced9e5d4499e9c6cfb962cba6c02889dd0d3a53fd88ccb0a0396e00551'

data/README.md

@@ -18,33 +18,52 @@ gem install ckmeans
 
 ## Usage
 
-### Fixed Cluster Count
+### Basic Clustering
 
 ```rb
-# Fixed cluster count
-Ckmeans::Clusterer(data, kmin).clusters
-Ckmedian::Clusterer(data, kmin).clusters
+# Fixed cluster count (K known in advance)
+Ckmeans::Clusterer.new(data, 3).clusters
+Ckmedian::Clusterer.new(data, 3).clusters
+
+# Automatic K selection (tries K from kmin to kmax, picks optimal)
+Ckmeans::Clusterer.new(data, 1, 10).clusters
+Ckmedian::Clusterer.new(data, 1, 10).clusters
 ```
 
-### Estimate optimal cluster count within kmin and kmax
+### Choosing Between Ckmeans and Ckmedian
+
+- **Ckmeans** - Minimizes squared distances (L2). Good for normally distributed data.
+- **Ckmedian** - Minimizes absolute distances (L1). More robust to outliers and data bursts.
 
 ```rb
-Ckmeans::Clusterer(data, kmin, kmax).clusters
-Ckmedian::Clusterer(data, kmin, kmax).clusters
+# For clean numerical data
+temperatures = [20.1, 20.2, 25.5, 25.6, 30.1, 30.2]
+Ckmeans::Clusterer.new(temperatures, 1, 5).clusters
+# => [[20.1, 20.2], [25.5, 25.6], [30.1, 30.2]]
+
+# For data with outliers (e.g., photo timestamps with bursts)
+timestamps = photos.map(&:taken_at).map(&:to_i)
+Ckmedian::Clusterer.new(timestamps, 1, 20).clusters
 ```
 
-### Fast & Stable Estimation of K
+### Stable Estimation (Recommended for Edge Cases)
 
-For big collections without many duplicates, use regular estimation.
-For relatively small sets or sets with many duplicates use Gaussian Mixture Model (GMM)-based estimation.
-It works slower but is more resilient for various data patterns like big numbers of duplicates or clusters with different
-numbers of elements.
+By default, both algorithms use a fast heuristic for estimating K. For datasets with many duplicates, tight clusters, or outliers, use `:stable` for more robust estimation:
 
 ```rb
-Ckmeans::Clusterer(data, kmin, kmax, :gmm).clusters
-Ckmedian::Clusterer(data, kmin, kmax, :gmm).clusters
+# Stable estimation (uses statistical mixture models)
+Ckmeans::Clusterer.new(data, 1, 10, :stable).clusters
+Ckmedian::Clusterer.new(data, 1, 10, :stable).clusters
 ```
 
+**When to use `:stable`:**
+- Small to medium datasets (< 1000 points)
+- Many duplicate values
+- Clusters with very different sizes
+- Photo/event timeline clustering (bursts and gaps)
+
+**Expert users:** `:stable` is an alias for `:gmm` (Gaussian Mixture Model) in Ckmeans and `:lmm` (Laplace Mixture Model) in Ckmedian.
+
 ## License
 
 The gem is available as open source under the terms of the [LGPL v3 License](https://opensource.org/license/lgpl-3-0).

data/ext/ckmeans/algorithm.inc

@@ -0,0 +1,281 @@
+/* SMAWK algorithm implementation template
+ *
+ * This file is designed to be included multiple times with different DISSIM_SUFFIX and DISSIM macro definitions
+ * to generate L1 and L2 specific versions of the clustering algorithm.
+ *
+ * Before including this file, define:
+ *   DISSIM_SUFFIX              - suffix for function names (e.g., l1, l2)
+ *   DISSIM(j, i, xsum, xsumsq) - macro that calls the dissimilarity function
+ *
+ * Example:
+ *   #define DISSIM_SUFFIX l2
+ *   #define DISSIM(j, i, xsum, xsumsq) dissimilarity_l2(j, i, xsum, xsumsq)
+ *   #include "algorithm.inc"
+ *   #undef DISSIM
+ *   #undef DISSIM_SUFFIX
+ */
+
+#ifndef DISSIM_SUFFIX
+#error "DISSIM_SUFFIX must be defined before including algorithm.inc"
+#endif
+
+#ifndef DISSIM
+#error "DISSIM must be defined before including algorithm.inc"
+#endif
+
+/* Helper macros for token pasting */
+#define CONCAT_IMPL(a, b) a##_##b
+#define CONCAT(a, b) CONCAT_IMPL(a, b)
+#define FUNC_NAME(name) CONCAT(name, DISSIM_SUFFIX)
+
+static inline void FUNC_NAME(fill_even_positions)(State state, RowParams rparams, VectorI *split_candidates)
+{
+    uint32_t row     = rparams.row;
+    uint32_t imin    = rparams.imin;
+    uint32_t imax    = rparams.imax;
+    uint32_t istep   = rparams.istep;
+    uint32_t n       = split_candidates->size;
+    uint32_t istepx2 = istep * 2;
+    uint32_t jl      = vector_get_i(split_candidates, 0);
+    VectorF *const xsum    = state.xsum;
+    VectorF *const xsumsq  = state.xsumsq;
+    MatrixI *const splits  = state.splits;
+
+    for (uint32_t i = imin, r = 0; i <= imax; i += istepx2) {
+        while (vector_get_i(split_candidates, r) < jl) r++;
+
+        uint32_t rcandidate    = vector_get_i(split_candidates, r);
+        uint32_t cost_base_row = row - 1;
+        uint32_t cost_base_col = rcandidate - 1;
+        LDouble cost           = matrix_get_f(state.cost, cost_base_row, cost_base_col)
+                               + DISSIM(rcandidate, i, xsum, xsumsq);
+
+        matrix_set_f(state.cost, row, i, cost);
+        matrix_set_i(state.splits, row, i, rcandidate);
+
+        uint32_t jh = (i + istep) <= imax
+            ? matrix_get_i(splits, row, i + istep)
+            : vector_get_i(split_candidates, n - 1);
+
+        uint32_t jmax  = jh < i ? jh : i;
+        LDouble sjimin = DISSIM(jmax, i, xsum, xsumsq);
+
+        for (++r; r < n && vector_get_i(split_candidates, r) <= jmax; r++) {
+            uint32_t jabs = vector_get_i(split_candidates, r);
+
+            if (jabs > i) break;
+            if (jabs < matrix_get_i(splits, row - 1, i)) continue;
+
+            LDouble cost_base = matrix_get_f(state.cost, row - 1, jabs  - 1);
+            LDouble sj        = cost_base + DISSIM(jabs, i, xsum, xsumsq);
+            LDouble cost_prev = matrix_get_f(state.cost, row, i);
+
+            if (sj <= cost_prev) {
+                matrix_set_f(state.cost, row, i, sj);
+                matrix_set_i(state.splits, row, i, jabs);
+            } else if (cost_base + sjimin > cost_prev) {
+                break;
+            }
+        }
+
+        r--;
+        jl = jh;
+    }
+}
+
+static inline void FUNC_NAME(find_min_from_candidates)(State state, RowParams rparams, VectorI *split_candidates)
+{
+    const uint32_t row     = rparams.row;
+    const uint32_t imin    = rparams.imin;
+    const uint32_t imax    = rparams.imax;
+    const uint32_t istep   = rparams.istep;
+    MatrixF *const cost    = state.cost;
+    MatrixI *const splits  = state.splits;
+
+    uint32_t optimal_split_idx_prev = 0;
+
+    for (uint32_t i = imin; i <= imax; i += istep)
+    {
+        const uint32_t optimal_split_idx = optimal_split_idx_prev;
+        const uint32_t optimal_split     = vector_get_i(split_candidates, optimal_split_idx);
+        const uint32_t cost_prev         = matrix_get_f(cost, row - 1, optimal_split - 1);
+        const LDouble added_cost         = DISSIM(optimal_split, i, state.xsum, state.xsumsq);
+
+        matrix_set_f(cost, row, i, cost_prev + added_cost);
+        matrix_set_i(splits, row, i, optimal_split);
+
+        for (uint32_t r = optimal_split_idx + 1; r < split_candidates->size; r++)
+        {
+            uint32_t split = vector_get_i(split_candidates, r);
+
+            if (split < matrix_get_i(splits, row - 1, i)) continue;
+            if (split > i) break;
+
+            LDouble split_cost = matrix_get_f(cost, row - 1, split - 1) + DISSIM(split, i, state.xsum, state.xsumsq);
+
+            if (split_cost > matrix_get_f(cost, row, i)) continue;
+
+            matrix_set_f(cost, row, i, split_cost);
+            matrix_set_i(splits, row, i, split);
+            optimal_split_idx_prev = r;
+        }
+    }
+}
+
+static inline VectorI *FUNC_NAME(prune_candidates)(State state, RowParams rparams, VectorI *split_candidates)
+{
+    uint32_t imin  = rparams.imin;
+    uint32_t row   = rparams.row;
+    uint32_t istep = rparams.istep;
+    uint32_t n     = ((rparams.imax - imin) / istep) + 1;
+    uint32_t m     = split_candidates->size;
+
+    if (n >= m) return split_candidates;
+
+    uint32_t left   = 0;
+    uint32_t right  = 0;
+    VectorI *pruned = vector_dup_i(split_candidates, state.arena);
+
+    while (m > n)
+    {
+        uint32_t i     = imin + left * istep;
+        uint32_t j     = vector_get_i(pruned, right);
+        uint32_t jnext = vector_get_i(pruned, right + 1);
+        LDouble sl     = matrix_get_f(state.cost, row - 1, j - 1) + DISSIM(j, i, state.xsum, state.xsumsq);
+        LDouble snext  = matrix_get_f(state.cost, row - 1, jnext - 1) + DISSIM(jnext, i, state.xsum, state.xsumsq);
+
+        if ((sl < snext) && (left < n - 1)) {
+            vector_set_i(pruned, left, j);
+            left++;
+            right++;
+        } else if ((sl < snext) && (left == n - 1)) {
+            right++;
+            m--;
+            vector_set_i(pruned, right, j);
+        } else {
+            if (left > 0) {
+                vector_set_i(pruned, right, vector_get_i(pruned, --left));
+            } else {
+                right++;
+            }
+
+            m--;
+        }
+    }
+
+    for (uint32_t i = left; i < m; i++) {
+        vector_set_i(pruned, i, vector_get_i(pruned, right++));
+    }
+
+    vector_downsize_i(pruned, m);
+
+    return pruned;
+}
+
+void FUNC_NAME(smawk)(State state, RowParams rparams, VectorI *split_candidates)
+{
+    const uint32_t imin  = rparams.imin;
+    const uint32_t imax  = rparams.imax;
+    const uint32_t istep = rparams.istep;
+
+    if ((imax - imin) <= (0 * istep)) {
+        FUNC_NAME(find_min_from_candidates)(state, rparams, split_candidates);
+    } else {
+        VectorI *odd_candidates = FUNC_NAME(prune_candidates)(state, rparams, split_candidates);
+        uint32_t istepx2        = istep * 2;
+        uint32_t imin_odd       = imin + istep;
+        uint32_t imax_odd       = imin_odd + ((imax - imin_odd) / istepx2 * istepx2);
+        RowParams rparams_odd   = { .row = rparams.row, .imin = imin_odd, .imax = imax_odd, .istep = istepx2 };
+
+        FUNC_NAME(smawk)(state, rparams_odd, odd_candidates);
+        FUNC_NAME(fill_even_positions)(state, rparams, split_candidates);
+    }
+}
+
+void FUNC_NAME(fill_row)(State state, uint32_t q, uint32_t imin, uint32_t imax)
+{
+    uint32_t size = imax - q + 1;
+    VectorI *split_candidates = vector_create_i(state.arena, size);
+    for (uint32_t i = 0; i < size; i++) {
+        vector_set_i(split_candidates, i, q + i);
+    }
+    RowParams rparams = { .row = q, .imin = imin, .imax = imax, .istep = 1 };
+    FUNC_NAME(smawk)(state, rparams, split_candidates);
+}
+
+VALUE FUNC_NAME(rb_sorted_group_sizes)(VALUE self, FnFindKOptimal *find_koptimal)
+{
+    uint32_t xcount  = NUM2UINT(rb_iv_get(self, "@xcount"));
+    uint32_t kmin    = NUM2UINT(rb_iv_get(self, "@kmin"));
+    uint32_t kmax    = NUM2UINT(rb_iv_get(self, "@kmax"));
+    VALUE rb_xsorted = rb_iv_get(self, "@xsorted");
+    size_t capacity  = sizeof(LDouble) * (xcount + 2) * (kmax + 2) * ALLOCATION_FACTOR + ARENA_MIN_CAPACITY;
+    Arena *arena     = arena_create(capacity);
+
+    if (arena == NULL) rb_raise(rb_eNoMemError, "Arena Memory Allocation Failed");
+
+    MatrixF *cost    = matrix_create_f(arena, kmax, xcount);
+    MatrixI *splits  = matrix_create_i(arena, kmax, xcount);
+    VectorF *xsorted = vector_create_f(arena, xcount);
+    VectorF *xsum    = vector_create_f(arena, xcount);
+    VectorF *xsumsq  = vector_create_f(arena, xcount);
+
+    for (uint32_t i = 0; i < xcount; i++) {
+        LDouble xi = NUM2DBL(rb_ary_entry(rb_xsorted, i));
+        vector_set_f(xsorted, i, xi);
+    }
+
+    State state = {
+        .arena   = arena,
+        .xcount  = xcount,
+        .kmin    = kmin,
+        .kmax    = kmax,
+        .xsorted = xsorted,
+        .cost    = cost,
+        .splits  = splits,
+        .xsum    = xsum,
+        .xsumsq  = xsumsq
+    };
+
+    LDouble shift        = vector_get_f(xsorted, xcount / 2);
+    LDouble diff_initial = vector_get_f(xsorted, 0) - shift;
+
+    vector_set_f(xsum, 0, diff_initial);
+    vector_set_f(xsumsq, 0, diff_initial * diff_initial);
+
+    for (uint32_t i = 1; i < xcount; i++) {
+        LDouble xi          = vector_get_f(xsorted, i);
+        LDouble xsum_prev   = vector_get_f(xsum, i - 1);
+        LDouble xsumsq_prev = vector_get_f(xsumsq, i - 1);
+        LDouble diff        = xi - shift;
+
+        vector_set_f(xsum, i, xsum_prev + diff);
+        vector_set_f(xsumsq, i, xsumsq_prev + diff * diff);
+        matrix_set_f(cost, 0, i, DISSIM(0, i, xsum, xsumsq));
+        matrix_set_i(splits, 0, i, 0);
+    }
+
+    for (uint32_t q = 1; q <= kmax - 1; q++) {
+        uint32_t imin = (q < kmax - 1) ? ((q > 1) ? q : 1) : xcount - 1;
+        FUNC_NAME(fill_row)(state, q, imin, xcount - 1);
+    }
+
+    uint32_t koptimal = find_koptimal(state);
+
+    VectorI *sizes = vector_create_i(arena, koptimal);
+    backtrack_sizes(state, sizes, koptimal);
+
+    VALUE response = rb_ary_new2(sizes->size);
+    for (uint32_t i = 0; i < sizes->size; i++) {
+        VALUE size = LONG2NUM(vector_get_i(sizes, i));
+        rb_ary_store(response, i, size);
+    }
+
+    arena_destroy(arena);
+
+    return response;
+}
+
+#undef CONCAT_IMPL
+#undef CONCAT
+#undef FUNC_NAME

data/ext/ckmeans/dissimilarity.h

@@ -0,0 +1,65 @@
+#ifndef DISSIMILARITY_H
+#define DISSIMILARITY_H
+
+/* L2 aka Euclidean aka Mean dissimilarity criteria */
+static inline LDouble dissimilarity_l2(uint32_t j, uint32_t i, VectorF *restrict xsum, VectorF *restrict xsumsq)
+{
+    LDouble sji = 0.0;
+
+    if (j >= i) return sji;
+
+    if (j > 0) {
+        LDouble segment_diff  = vector_get_diff_f(xsum, i, j - 1);
+        uint32_t segment_size = i - j + 1;
+        sji = vector_get_diff_f(xsumsq, i, j - 1) - (segment_diff * segment_diff / segment_size);
+    } else {
+        LDouble xsumi = vector_get_f(xsum, i);
+        sji = vector_get_f(xsumsq, i) - (xsumi * xsumi / (i + 1));
+    }
+
+    return (sji > 0) ? sji : 0.0;
+}
+
+/* L1 aka Manhattan aka Median dissimilarity criteria */
+static inline LDouble dissimilarity_l1(uint32_t j, uint32_t i, VectorF *restrict xsum, VectorF *restrict _xsumsq)
+{
+    LDouble sji = 0.0;
+
+    if (j >= i) return sji;
+
+    if (j > 0) {
+        uint32_t median_idx = (i + j) >> 1;
+
+        if (((i - j + 1) % 2) == 1) {
+            sji =
+                - vector_get_f(xsum, median_idx - 1)
+                + vector_get_f(xsum, j - 1)
+                + vector_get_f(xsum, i)
+                - vector_get_f(xsum, median_idx);
+        } else {
+            sji =
+                - vector_get_f(xsum, median_idx)
+                + vector_get_f(xsum, j - 1)
+                + vector_get_f(xsum, i)
+                - vector_get_f(xsum, median_idx);
+        }
+    } else { // j == 0
+        uint32_t median_idx = i >> 1;
+
+        if (((i + 1) % 2) == 1) {
+            sji =
+                - vector_get_f(xsum, median_idx - 1)
+                + vector_get_f(xsum, i)
+                - vector_get_f(xsum, median_idx);
+        } else {
+            sji =
+                - vector_get_f(xsum, median_idx)
+                + vector_get_f(xsum, i)
+                - vector_get_f(xsum, median_idx);
+        }
+    }
+
+    return (sji < 0) ? 0.0 : sji;
+}
+
+#endif /* DISSIMILARITY_H */

data/ext/ckmeans/extensions.c

@@ -33,8 +33,6 @@ typedef struct VectorI {
     uint32_t *values;
 } VectorI;
 
-typedef LDouble (FnDissim)(uint32_t, uint32_t, VectorF*, VectorF*);
-
 typedef struct State {
     uint32_t xcount;
     uint32_t kmin;
@@ -45,7 +43,6 @@ typedef struct State {
     MatrixI *splits;
     VectorF *xsum;
     VectorF *xsumsq;
-    FnDissim *dissim;
 } State;
 
 typedef struct RowParams {
@@ -55,6 +52,8 @@ typedef struct RowParams {
     uint32_t istep;
 } RowParams;
 
+typedef uint32_t (FnFindKOptimal)(State);
+
 typedef struct {
     LDouble mean;
     LDouble variance;
@@ -62,7 +61,6 @@ typedef struct {
 
 VALUE rb_ckmeans_sorted_group_sizes(VALUE self);
 VALUE rb_ckmedian_sorted_group_sizes(VALUE self);
-VALUE rb_sorted_group_sizes(VALUE self, FnDissim*);
 
 Arena *arena_create(size_t);
 void  *arena_alloc(Arena*, size_t);
@@ -89,17 +87,11 @@ uint32_t vector_get_i(VectorI*, uint32_t offset);
 void     vector_downsize_i(VectorI*, uint32_t);
 void     vector_inspect_i(VectorI*);
 
-LDouble      dissimilarity_l2(uint32_t, uint32_t, VectorF*, VectorF*);
-LDouble      dissimilarity_l1(uint32_t, uint32_t, VectorF*, VectorF*);
-void         fill_row(State, uint32_t, uint32_t, uint32_t);
-void         smawk(State, RowParams, VectorI*);
-void         find_min_from_candidates(State, RowParams, VectorI*);
-VectorI      *prune_candidates(State, RowParams, VectorI*);
-void         fill_even_positions(State, RowParams, VectorI*);
 SegmentStats shifted_data_variance(VectorF*, uint32_t, uint32_t);
 VectorI      *backtrack_sizes(State, VectorI*, uint32_t);
 uint32_t     find_koptimal_fast(State);
 uint32_t     find_koptimal_gmm(State);
+uint32_t     find_koptimal_lmm(State);
 
 void Init_extensions(void) {
     VALUE ckmeans_module     = rb_const_get(rb_cObject, rb_intern("Ckmeans"));
@@ -115,96 +107,34 @@ void Init_extensions(void) {
 # define ALLOCATION_FACTOR 3
 # define PIx2 (M_PI * 2.0)
 
+#include "dissimilarity.h"
+
+/* L2-specific versions of all hot-path functions */
+#define DISSIM_SUFFIX l2
+#define DISSIM(j, i, xsum, xsumsq) dissimilarity_l2(j, i, xsum, xsumsq)
+#include "algorithm.inc"
+#undef DISSIM
+#undef DISSIM_SUFFIX
+
+/* L1-specific versions of all hot-path functions */
+#define DISSIM_SUFFIX l1
+#define DISSIM(j, i, xsum, xsumsq) dissimilarity_l1(j, i, xsum, xsumsq)
+#include "algorithm.inc"
+#undef DISSIM
+#undef DISSIM_SUFFIX
+
 VALUE rb_ckmeans_sorted_group_sizes(VALUE self)
 {
-    return rb_sorted_group_sizes(self, dissimilarity_l2);
+    bool use_stable = RTEST(rb_iv_get(self, "@use_stable_estimation"));
+    FnFindKOptimal *find_k = use_stable ? find_koptimal_gmm : find_koptimal_fast;
+    return rb_sorted_group_sizes_l2(self, find_k);
 }
 
 VALUE rb_ckmedian_sorted_group_sizes(VALUE self)
 {
-    return rb_sorted_group_sizes(self, dissimilarity_l1);
-}
-
-VALUE rb_sorted_group_sizes(VALUE self, FnDissim *criteria)
-{
-    uint32_t xcount  = NUM2UINT(rb_iv_get(self, "@xcount"));
-    uint32_t kmin    = NUM2UINT(rb_iv_get(self, "@kmin"));
-    uint32_t kmax    = NUM2UINT(rb_iv_get(self, "@kmax"));
-    bool use_gmm     = RTEST(rb_iv_get(self, "@use_gmm"));
-    VALUE rb_xsorted = rb_iv_get(self, "@xsorted");
-    size_t capacity  = sizeof(LDouble) * (xcount + 2) * (kmax + 2) * ALLOCATION_FACTOR + ARENA_MIN_CAPACITY;
-    Arena *arena     = arena_create(capacity);
-
-    if (arena == NULL) rb_raise(rb_eNoMemError, "Arena Memory Allocation Failed");
-
-    MatrixF *cost    = matrix_create_f(arena, kmax, xcount);
-    MatrixI *splits  = matrix_create_i(arena, kmax, xcount);
-    VectorF *xsorted = vector_create_f(arena, xcount);
-    VectorF *xsum    = vector_create_f(arena, xcount);
-    VectorF *xsumsq  = vector_create_f(arena, xcount);
-
-    for (uint32_t i = 0; i < xcount; i++) {
-        LDouble xi = NUM2DBL(rb_ary_entry(rb_xsorted, i));
-        vector_set_f(xsorted, i, xi);
-    }
-
-    State state = {
-        .arena   = arena,
-        .xcount  = xcount,
-        .kmin    = kmin,
-        .kmax    = kmax,
-        .xsorted = xsorted,
-        .cost    = cost,
-        .splits  = splits,
-        .xsum    = xsum,
-        .xsumsq  = xsumsq,
-        .dissim  = criteria
-    };
-
-
-    LDouble shift        = vector_get_f(xsorted, xcount / 2);
-    LDouble diff_initial = vector_get_f(xsorted, 0) - shift;
-
-    vector_set_f(xsum, 0, diff_initial);
-    vector_set_f(xsumsq, 0, diff_initial * diff_initial);
-
-    for (uint32_t i = 1; i < xcount; i++) {
-        LDouble xi          = vector_get_f(xsorted, i);
-        LDouble xsum_prev   = vector_get_f(xsum, i - 1);
-        LDouble xsumsq_prev = vector_get_f(xsumsq, i - 1);
-        LDouble diff        = xi - shift;
-
-        vector_set_f(xsum, i, xsum_prev + diff);
-        vector_set_f(xsumsq, i, xsumsq_prev + diff * diff);
-        matrix_set_f(cost, 0, i, criteria(0, i, xsum, xsumsq));
-        matrix_set_i(splits, 0, i, 0);
-    }
-
-    for (uint32_t q = 1; q <= kmax - 1; q++) {
-        uint32_t imin = (q < kmax - 1) ? ((q > 1) ? q : 1) : xcount - 1;
-        fill_row(state, q, imin, xcount - 1);
-    }
-
-    uint32_t koptimal = use_gmm ? find_koptimal_gmm(state) : find_koptimal_fast(state);
-
-    VectorI *sizes = vector_create_i(arena, koptimal);
-    backtrack_sizes(state, sizes, koptimal);
-
-    /* printf("XSORTED \t"); vector_inspect_f(xsorted); */
-    /* printf("K OPTIMAL: %lld\n", koptimal); */
-    /* printf("SIZES \t"); vector_inspect_i(sizes); */
-    /* printf("FINAL COST\n"); matrix_inspect_f(cost); */
-    /* printf("FINAL SPLITS\n"); matrix_inspect_i(splits); */
-
-    VALUE response = rb_ary_new2(sizes->size);
-    for (uint32_t i = 0; i < sizes->size; i++) {
-        VALUE size = LONG2NUM(vector_get_i(sizes, i));
-        rb_ary_store(response, i, size);
-    }
-
-    arena_destroy(arena);
-
-    return response;
+    bool use_stable = RTEST(rb_iv_get(self, "@use_stable_estimation"));
+    FnFindKOptimal *find_k = use_stable ? find_koptimal_lmm : find_koptimal_fast;
+    return rb_sorted_group_sizes_l1(self, find_k);
 }
 
 uint32_t find_koptimal_fast(State state)
@@ -372,292 +302,162 @@ uint32_t find_koptimal_gmm(State state)
     return kopt;
 }
 
-VectorI *backtrack_sizes(State state, VectorI *sizes, uint32_t k)
+uint32_t find_koptimal_lmm(State state)
 {
-    MatrixI *splits = state.splits;
+    uint32_t kmin = state.kmin;
+    uint32_t kmax = state.kmax;
     uint32_t xcount = state.xcount;
-    uint32_t right  = xcount - 1;
-    uint32_t left   = 0;
 
-    // Common case works with `i` remaining unsigned and unconditional assignment of the next `left` and `right`
-    for (uint32_t i = k - 1; i > 0; i--, right = left - 1) {
-        left = matrix_get_i(splits, i, right);
-        vector_set_i(sizes, i, right - left + 1);
+    if (kmin > kmax || xcount < 2) {
+        return (kmin < kmax) ? kmin : kmax;
     }
-    // Special case outside of the loop removing the need for conditionals
-    left = matrix_get_i(splits, 0, right);
-    vector_set_i(sizes, 0, right - left + 1);
 
-    return sizes;
-}
+    Arena *arena       = state.arena;
+    VectorF *xsorted   = state.xsorted;
+    uint32_t kopt      = kmin;
+    LDouble max_bic    = 0.0;
+    LDouble log_xcount = log((LDouble) xcount);
+    VectorF *lambda    = vector_create_f(arena, kmax);
+    VectorF *mu        = vector_create_f(arena, kmax);  /* median */
+    VectorF *scale     = vector_create_f(arena, kmax);  /* MAD (mean absolute deviation) */
+    VectorF *coeff     = vector_create_f(arena, kmax);
+    VectorI *sizes     = vector_create_i(arena, kmax);
 
-SegmentStats shifted_data_variance(VectorF *xsorted, uint32_t left, uint32_t right)
-{
-    const uint32_t n   = right - left + 1;
-    LDouble sum        = 0.0;
-    LDouble sumsq      = 0.0;
-    SegmentStats stats = { .mean = 0.0, .variance = 0.0 };
+    for (uint32_t kouter = kmin; kouter <= kmax; ++kouter)
+    {
+        uint32_t ileft = 0;
+        uint32_t iright;
 
-    if (right >= left) {
-        const LDouble median = vector_get_f(xsorted, (left + right) / 2);
+        backtrack_sizes(state, sizes, kouter);
 
-        for (uint32_t i = left; i <= right; i++) {
-            const LDouble sumi = vector_get_f(xsorted, i) - median;
+        for (uint32_t k = 0; k < kouter; ++k)
+        {
+            uint32_t size = vector_get_i(sizes, k);
+            vector_set_f(lambda, k, size / (LDouble) xcount);
+            iright = ileft + size - 1;
 
-            sum   += sumi;
-            sumsq += sumi * sumi;
-        }
+            uint32_t median_idx = (ileft + iright) / 2;
+            LDouble median;
+            if ((size % 2) == 1) {
+                median = vector_get_f(xsorted, median_idx);
+            } else {
+                median = (vector_get_f(xsorted, median_idx) + vector_get_f(xsorted, median_idx + 1)) / 2.0;
+            }
+            vector_set_f(mu, k, median);
 
-        stats.mean = (sum / n) + median;
-        if (n > 1) {
-            stats.variance = (sumsq - (sum * sum / n)) / (n - 1);
-        }
-    }
+            LDouble mad = 0.0;
+            for (uint32_t i = ileft; i <= iright; ++i) {
+                LDouble xi = vector_get_f(xsorted, i);
+                mad += fabs(xi - median);
+            }
+            mad = mad / size;
+            vector_set_f(scale, k, mad);
 
-    return stats;
-}
+            /* Handle edge case: MAD = 0 (all points are the same) or size = 1 */
+            if (mad == 0 || size == 1) {
+                LDouble dmin;
 
-void fill_row(State state, uint32_t q, uint32_t imin, uint32_t imax)
-{
-    uint32_t size = imax - q + 1;
-    VectorI *split_candidates = vector_create_i(state.arena, size);
-    for (uint32_t i = 0; i < size; i++) {
-        vector_set_i(split_candidates, i, q + i);
-    }
-    RowParams rparams = { .row = q, .imin = imin, .imax = imax, .istep = 1 };
-    smawk(state, rparams, split_candidates);
-}
+                if (ileft > 0 && iright < xcount - 1) {
+                    LDouble left_diff = vector_get_diff_f(xsorted, ileft, ileft - 1);
+                    LDouble right_diff = vector_get_diff_f(xsorted, iright + 1, iright);
 
-void smawk(State state, RowParams rparams, VectorI *split_candidates)
-{
-    const uint32_t imin  = rparams.imin;
-    const uint32_t imax  = rparams.imax;
-    const uint32_t istep = rparams.istep;
-
-    if ((imax - imin) <= (0 * istep)) {
-        find_min_from_candidates(state, rparams, split_candidates);
-    } else {
-        VectorI *odd_candidates = prune_candidates(state, rparams, split_candidates);
-        /* printf("PRUNED\t"); vector_inspect_i(odd_candidates); */
-        uint32_t istepx2        = istep * 2;
-        uint32_t imin_odd       = imin + istep;
-        uint32_t imax_odd       = imin_odd + ((imax - imin_odd) / istepx2 * istepx2);
-        RowParams rparams_odd   = { .row = rparams.row, .imin = imin_odd, .imax = imax_odd, .istep = istepx2 };
-
-        smawk(state, rparams_odd, odd_candidates);
-        fill_even_positions(state, rparams, split_candidates);
-    }
-}
+                    dmin = (left_diff < right_diff) ? left_diff : right_diff;
+                } else if (ileft > 0) {
+                    dmin = vector_get_diff_f(xsorted, ileft, ileft - 1);
+                } else {
+                    dmin = vector_get_diff_f(xsorted, iright + 1, iright);
+                }
 
-inline void fill_even_positions(State state, RowParams rparams, VectorI *split_candidates)
-{
-    uint32_t row     = rparams.row;
-    uint32_t imin    = rparams.imin;
-    uint32_t imax    = rparams.imax;
-    uint32_t istep   = rparams.istep;
-    uint32_t n       = split_candidates->size;
-    uint32_t istepx2 = istep * 2;
-    uint32_t jl      = vector_get_i(split_candidates, 0);
-    VectorF *const xsum    = state.xsum;
-    VectorF *const xsumsq  = state.xsumsq;
-    MatrixI *const splits  = state.splits;
-    FnDissim *const dissim = state.dissim;
-
-    for (uint32_t i = imin, r = 0; i <= imax; i += istepx2) {
-        while (vector_get_i(split_candidates, r) < jl) r++;
-
-        uint32_t rcandidate    = vector_get_i(split_candidates, r);
-        uint32_t cost_base_row = row - 1;
-        uint32_t cost_base_col = rcandidate - 1;
-        LDouble cost           =
-            matrix_get_f(state.cost, cost_base_row, cost_base_col) + dissim(rcandidate, i, xsum, xsumsq);
-
-        matrix_set_f(state.cost, row, i, cost);
-        matrix_set_i(state.splits, row, i, rcandidate);
-
-        uint32_t jh =
-            (i + istep) <= imax
-            ? matrix_get_i(splits, row, i + istep)
-            : vector_get_i(split_candidates, n - 1);
-
-        uint32_t jmax  = jh < i ? jh : i;
-        LDouble sjimin = dissim(jmax, i, xsum, xsumsq);
-
-        for (++r; r < n && vector_get_i(split_candidates, r) <= jmax; r++) {
-            uint32_t jabs = vector_get_i(split_candidates, r);
-
-            if (jabs > i) break;
-            if (jabs < matrix_get_i(splits, row - 1, i)) continue;
-
-            LDouble cost_base = matrix_get_f(state.cost, row - 1, jabs  - 1);
-            LDouble sj        = cost_base + dissim(jabs, i, xsum, xsumsq);
-            LDouble cost_prev = matrix_get_f(state.cost, row, i);
-
-            if (sj <= cost_prev) {
-                matrix_set_f(state.cost, row, i, sj);
-                matrix_set_i(state.splits, row, i, jabs);
-            } else if (cost_base + sjimin > cost_prev) {
-                break;
+                if (mad == 0) vector_set_f(scale, k, dmin / 6.0);
+                if (size == 1) vector_set_f(scale, k, dmin);
             }
-        }
 
-        r--;
-        jl = jh;
-    }
-}
-
-inline void find_min_from_candidates(State state, RowParams rparams, VectorI *split_candidates)
-{
-    const uint32_t row     = rparams.row;
-    const uint32_t imin    = rparams.imin;
-    const uint32_t imax    = rparams.imax;
-    const uint32_t istep   = rparams.istep;
-    MatrixF *const cost    = state.cost;
-    MatrixI *const splits  = state.splits;
-    FnDissim *const dissim = state.dissim;
-
-    uint32_t optimal_split_idx_prev = 0;
-
-    for (uint32_t i = imin; i <= imax; i += istep)
-    {
-        const uint32_t optimal_split_idx = optimal_split_idx_prev;
-        const uint32_t optimal_split     = vector_get_i(split_candidates, optimal_split_idx);
-        const uint32_t cost_prev         = matrix_get_f(cost, row - 1, optimal_split - 1);
-        const LDouble added_cost         = dissim(optimal_split, i, state.xsum, state.xsumsq);
+            /* Laplace coefficient: lambda_k / (2 * b_k) */
+            LDouble lambda_k = vector_get_f(lambda, k);
+            LDouble scale_k  = vector_get_f(scale, k);
+            vector_set_f(coeff, k, lambda_k / (2.0 * scale_k));
+            ileft = iright + 1;
+        }
 
-        matrix_set_f(cost, row, i, cost_prev + added_cost);
-        matrix_set_i(splits, row, i, optimal_split);
+        LDouble loglikelihood = 0.0;
 
-        for (uint32_t r = optimal_split_idx + 1; r < split_candidates->size; r++)
+        for (uint32_t i = 0; i < xcount; ++i)
         {
-            uint32_t split = vector_get_i(split_candidates, r);
-
-            if (split < matrix_get_i(splits, row - 1, i)) continue;
-            if (split > i) break;
-
-            LDouble split_cost =
-                matrix_get_f(cost, row - 1, split - 1) + dissim(split, i, state.xsum, state.xsumsq);
-
-            if (split_cost > matrix_get_f(cost, row, i)) continue;
+            LDouble L  = 0.0;
+            LDouble xi = vector_get_f(xsorted, i);
 
-            matrix_set_f(cost, row, i, split_cost);
-            matrix_set_i(splits, row, i, split);
-            optimal_split_idx_prev = r;
+            for (uint32_t k = 0; k < kouter; ++k)
+            {
+                LDouble coeff_k  = vector_get_f(coeff, k);
+                LDouble mu_k     = vector_get_f(mu, k);
+                LDouble scale_k  = vector_get_f(scale, k);
+                LDouble x_mu_abs = fabs(xi - mu_k);
+                /* Laplace PDF: (1/(2b)) * exp(-|x-μ|/b) */
+                L               += coeff_k * exp(-x_mu_abs / scale_k);
+            }
+            loglikelihood += log(L);
         }
-    }
-}
-
-inline VectorI *prune_candidates(State state, RowParams rparams, VectorI *split_candidates)
-{
-    uint32_t imin  = rparams.imin;
-    uint32_t row   = rparams.row;
-    uint32_t istep = rparams.istep;
-    uint32_t n     = ((rparams.imax - imin) / istep) + 1;
-    uint32_t m     = split_candidates->size;
 
-    if (n >= m) return split_candidates;
-
-    uint32_t left   = 0;
-    uint32_t right  = 0;
-    VectorI *pruned = vector_dup_i(split_candidates, state.arena);
-    FnDissim *const dissim = state.dissim;
+        /* BIC = 2*logL - (3k-1)*log(n) */
+        /* Parameters: k-1 mixing proportions + k medians + k scales = 3k-1 */
+        LDouble bic = 2 * loglikelihood - (3 * kouter - 1) * log_xcount;
 
-    while (m > n)
-    {
-        uint32_t i     = imin + left * istep;
-        uint32_t j     = vector_get_i(pruned, right);
-        uint32_t jnext = vector_get_i(pruned, right + 1);
-        LDouble sl     =
-            matrix_get_f(state.cost, row - 1, j - 1) + dissim(j, i, state.xsum, state.xsumsq);
-        LDouble snext  =
-            matrix_get_f(state.cost, row - 1, jnext - 1) + dissim(jnext, i, state.xsum, state.xsumsq);
-
-        if ((sl < snext) && (left < n - 1)) {
-            vector_set_i(pruned, left, j);
-            left++;
-            right++;
-        } else if ((sl < snext) && (left == n - 1)) {
-            right++;
-            m--;
-            vector_set_i(pruned, right, j);
+        if (kouter == kmin) {
+            max_bic = bic;
+            kopt = kmin;
         } else {
-            if (left > 0) {
-                vector_set_i(pruned, right, vector_get_i(pruned, --left));
-            } else {
-                right++;
+            if (bic > max_bic) {
+                max_bic = bic;
+                kopt = kouter;
             }
-
-            m--;
         }
     }
-
-    for (uint32_t i = left; i < m; i++) {
-        vector_set_i(pruned, i, vector_get_i(pruned, right++));
-    }
-
-    vector_downsize_i(pruned, m);
-
-    return pruned;
+    return kopt;
 }
 
-/* L2 aka Euclidean aka Mean dissimilarity criteria */
-inline LDouble dissimilarity_l2(uint32_t j, uint32_t i, VectorF *restrict xsum, VectorF *restrict xsumsq) {
-    LDouble sji = 0.0;
-
-    if (j >= i) return sji;
+VectorI *backtrack_sizes(State state, VectorI *sizes, uint32_t k)
+{
+    MatrixI *splits = state.splits;
+    uint32_t xcount = state.xcount;
+    uint32_t right  = xcount - 1;
+    uint32_t left   = 0;
 
-    if (j > 0) {
-        LDouble segment_diff  = vector_get_diff_f(xsum, i, j - 1);
-        uint32_t segment_size = i - j + 1;
-        sji                   = vector_get_diff_f(xsumsq, i, j - 1) - (segment_diff * segment_diff / segment_size);
-    } else {
-        LDouble xsumi = vector_get_f(xsum, i);
-        sji           = vector_get_f(xsumsq, i) - (xsumi * xsumi / (i + 1));
+    /* Common case works with `i` remaining unsigned and unconditional assignment of the next `left` and `right` */
+    for (uint32_t i = k - 1; i > 0; i--, right = left - 1) {
+        left = matrix_get_i(splits, i, right);
+        vector_set_i(sizes, i, right - left + 1);
     }
+    /* Special case outside of the loop removing the need for conditionals */
+    left = matrix_get_i(splits, 0, right);
+    vector_set_i(sizes, 0, right - left + 1);
 
-    return (sji > 0) ? sji : 0.0;
+    return sizes;
 }
 
-/* L1 aka Manhattan aka Median dissimilarity criteria */
-inline LDouble dissimilarity_l1(uint32_t j, uint32_t i, VectorF *restrict xsum, VectorF *restrict _xsumsq)
+SegmentStats shifted_data_variance(VectorF *xsorted, uint32_t left, uint32_t right)
 {
-    LDouble sji = 0.0;
+    const uint32_t n   = right - left + 1;
+    LDouble sum        = 0.0;
+    LDouble sumsq      = 0.0;
+    SegmentStats stats = { .mean = 0.0, .variance = 0.0 };
 
-    if (j >= i) return sji;
+    if (right >= left) {
+        const LDouble median = vector_get_f(xsorted, (left + right) / 2);
 
-    if (j > 0) {
-        uint32_t median_idx = (i + j) >> 1;
+        for (uint32_t i = left; i <= right; i++) {
+            const LDouble sumi = vector_get_f(xsorted, i) - median;
 
-        if (((i - j + 1) % 2) == 1) {
-            sji =
-                - vector_get_f(xsum, median_idx - 1)
-                + vector_get_f(xsum, j - 1)
-                + vector_get_f(xsum, i)
-                - vector_get_f(xsum, median_idx);
-        } else {
-            sji =
-                - vector_get_f(xsum, median_idx)
-                + vector_get_f(xsum, j - 1)
-                + vector_get_f(xsum, i)
-                - vector_get_f(xsum, median_idx);
+            sum   += sumi;
+            sumsq += sumi * sumi;
         }
-    } else { // j == 0
-        uint32_t median_idx = i >> 1;
-
-        if (((i + 1) % 2) == 1) {
-            sji =
-                - vector_get_f(xsum, median_idx - 1)
-                + vector_get_f(xsum, i)
-                - vector_get_f(xsum, median_idx);
-        } else {
-            sji =
-                - vector_get_f(xsum, median_idx)
-                + vector_get_f(xsum, i)
-                - vector_get_f(xsum, median_idx);
+
+        stats.mean = (sum / n) + median;
+        if (n > 1) {
+            stats.variance = (sumsq - (sum * sum / n)) / (n - 1);
         }
     }
 
-    return (sji < 0) ? 0.0 : sji;
+    return stats;
 }
 
 inline VectorF *vector_create_f(Arena *arena, uint32_t size) {

data/lib/ckmeans/clusterer.rb

@@ -1,19 +1,37 @@
 # frozen_string_literal: true
 
 module Ckmeans
-  class Clusterer # rubocop:disable Style/Documentation
+  # Optimal k-means clustering for univariate (1D) data using dynamic programming.
+  # Minimizes within-cluster sum of squared distances (L2 norm).
+  class Clusterer
+    # Creates a new Ckmeans clusterer.
+    #
+    # @param entries [Array<Numeric>] The data points to cluster
+    # @param kmin [Integer] Minimum number of clusters to consider
+    # @param kmax [Integer] Maximum number of clusters to consider (defaults to kmin for fixed K)
+    # @param kestimate [Symbol] Method for estimating optimal K:
+    #   - :fast   - Quick heuristic using implicit Gaussian assumption (best for large datasets)
+    #   - :stable - Model-based estimation using Gaussian Mixture Model (better for duplicates/edge cases)
+    #   - :gmm    - Alias for :stable (Gaussian Mixture Model)
+    #
+    # @example Fixed number of clusters
+    #   Ckmeans::Clusterer.new([1, 2, 3, 100, 101], 2).clusters
+    #   # => [[1, 2, 3], [100, 101]]
+    #
+    # @example Automatic K selection with stable estimation
+    #   Ckmeans::Clusterer.new([1, 1, 1, 5, 5, 5, 10, 10, 10], 1, 5, :stable).clusters
     def initialize(entries, kmin, kmax = kmin, kestimate = :fast)
       @xcount = entries.size
 
       raise ArgumentError, "Minimum cluster count is bigger than element count" if kmin > @xcount
       raise ArgumentError, "Maximum cluster count is bigger than element count" if kmax > @xcount
 
-      @kmin             = kmin
-      @unique_xcount    = entries.uniq.size
-      @kmax             = [@unique_xcount, kmax].min
-      @xsorted_original = entries.sort
-      @xsorted          = @xsorted_original.map(&:to_f)
-      @use_gmm          = kestimate == :gmm
+      @kmin                  = kmin
+      @unique_xcount         = entries.uniq.size
+      @kmax                  = [@unique_xcount, kmax].min
+      @xsorted_original      = entries.sort
+      @xsorted               = @xsorted_original.map(&:to_f)
+      @use_stable_estimation = %i[gmm stable].include?(kestimate)
     end
 
     def clusters

data/lib/ckmeans/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ckmeans
-  VERSION = "2.0.0"
+  VERSION = "2.1.1"
 end

data/lib/ckmedian/clusterer.rb

@@ -1,18 +1,39 @@
 # frozen_string_literal: true
 
 module Ckmedian
-  class Clusterer # rubocop:disable Style/Documentation
-    def initialize(entries, kmin, kmax = kmin)
+  # Optimal k-median clustering for univariate (1D) data using dynamic programming.
+  # Minimizes within-cluster sum of absolute deviations (L1 norm).
+  # More robust to outliers than k-means.
+  class Clusterer
+    # Creates a new Ckmedian clusterer.
+    #
+    # @param entries [Array<Numeric>] The data points to cluster
+    # @param kmin [Integer] Minimum number of clusters to consider
+    # @param kmax [Integer] Maximum number of clusters to consider (defaults to kmin for fixed K)
+    # @param kestimate [Symbol] Method for estimating optimal K:
+    #   - :fast   - Quick heuristic using implicit Gaussian assumption (best for large datasets)
+    #   - :stable - Model-based estimation using Laplace Mixture Model (better for outliers/bursts)
+    #   - :lmm    - Alias for :stable (Laplace Mixture Model)
+    #
+    # @example Fixed number of clusters
+    #   Ckmedian::Clusterer.new([1, 2, 3, 100, 101], 2).clusters
+    #   # => [[1, 2, 3], [100, 101]]
+    #
+    # @example Photo timeline clustering (robust to bursts and outliers)
+    #   timestamps = photos.map(&:taken_at).map(&:to_i)
+    #   Ckmedian::Clusterer.new(timestamps, 1, 20, :stable).clusters
+    def initialize(entries, kmin, kmax = kmin, kestimate = :fast)
       @xcount = entries.size
 
       raise ArgumentError, "Minimum cluster count is bigger than element count" if kmin > @xcount
       raise ArgumentError, "Maximum cluster count is bigger than element count" if kmax > @xcount
 
-      @kmin             = kmin
-      @unique_xcount    = entries.uniq.size
-      @kmax             = [@unique_xcount, kmax].min
-      @xsorted_original = entries.sort
-      @xsorted          = @xsorted_original.map(&:to_f)
+      @kmin                  = kmin
+      @unique_xcount         = entries.uniq.size
+      @kmax                  = [@unique_xcount, kmax].min
+      @xsorted_original      = entries.sort
+      @xsorted               = @xsorted_original.map(&:to_f)
+      @use_stable_estimation = %i[lmm stable].include?(kestimate)
     end
 
     def clusters

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ckmeans
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.1
 platform: ruby
 authors:
 - Vlad Lebedev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-06-09 00:00:00.000000000 Z
+date: 2025-12-14 00:00:00.000000000 Z
 dependencies: []
 description: Repeatable clustering of unidimensional data
 email:
@@ -28,6 +28,8 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- ext/ckmeans/algorithm.inc
+- ext/ckmeans/dissimilarity.h
 - ext/ckmeans/extconf.rb
 - ext/ckmeans/extensions.c
 - lib/ckmeans.rb