ckmeans 1.0.4 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17dd59ae47e814d5cf0b45665856a52e33e1af22c90722955750004405633a4e
-  data.tar.gz: 4278bb18d8a987ac71fd7ea179055ab6d2c15292d772b7d9df1dd8c4adde011b
+  metadata.gz: 1d63d8f65d386bf27082e0a65b1ea82a7d150394b1424ab5c2c274e139f91482
+  data.tar.gz: 1f3c4e91fcc9f3bda3d83521cac164ff83e3e5095705cd15420c6278635fc266
 SHA512:
-  metadata.gz: 7e3d19cfbfbebb0b26bf1ffdd7c99998a898ccf123359994e339147735b819f3f16fc73c2ac202a3fbe3c4f1c13c747e7181d01d56770be5404ca6354533b23d
-  data.tar.gz: 2be82db12f8d9da2cafb03713440f3083d2ffd7fd7f6917ad8e98d1c864b1d97f99e9a0771afe6aaaff502fee86d81e9221b8d689a388817b060fc7ce1917a87
+  metadata.gz: 0101cd5f6d5ba925d8f37cc73416008ace4ffce7ea33a437e0189549ede4cbc23b7284de2fe28af181ddf08396b74225c67626e94ce015d54ac14fde17b53bda
+  data.tar.gz: abbcc012e9378ea1fbf15566fd47691bd4cecaaeaf95947c45414dfb7b304db87d803120749aab3ccbf806ab90dd554cce2461f340c348e4f1b820f47be421a2

data/.ruby-version

@@ -1 +1 @@
-3.2.2
+3.2.8

data/README.md

@@ -18,10 +18,31 @@ gem install ckmeans
 
 ## Usage
 
+### Fixed Cluster Count
+
+```rb
+# Fixed cluster count
+Ckmeans::Clusterer(data, kmin).clusters
+Ckmedian::Clusterer(data, kmin).clusters
+```
+
+### Estimate optimal cluster count within kmin and kmax
+
+```rb
+Ckmeans::Clusterer(data, kmin, kmax).clusters
+Ckmedian::Clusterer(data, kmin, kmax).clusters
+```
+
+### Fast & Stable Estimation of K
+
+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.
+
 ```rb
-Ckmeans::Clusterer(data, kmin).clusters # fixed cluster count
-Ckmeans::Clusterer(data, kmin, kmax).clusters # estimate optimal cluster count within kmin and kmax
-Ckmeans::Clusterer(data, kmin, kmax, :sensitive).clusters # Adjust Bayesian Information Criteria favoring more smaller clusters
+Ckmeans::Clusterer(data, kmin, kmax, :gmm).clusters
+Ckmedian::Clusterer(data, kmin, kmax, :gmm).clusters
 ```
 
 ## License

data/ext/ckmeans/extensions.c

@@ -33,17 +33,19 @@ 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;
     uint32_t kmax;
-    bool     apply_deviation;
     Arena   *arena;
     VectorF *xsorted;
     MatrixF *cost;
     MatrixI *splits;
     VectorF *xsum;
     VectorF *xsumsq;
+    FnDissim *dissim;
 } State;
 
 typedef struct RowParams {
@@ -59,6 +61,8 @@ typedef struct {
 } SegmentStats;
 
 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);
@@ -85,7 +89,8 @@ uint32_t vector_get_i(VectorI*, uint32_t offset);
 void     vector_downsize_i(VectorI*, uint32_t);
 void     vector_inspect_i(VectorI*);
 
-LDouble      dissimilarity(uint32_t, uint32_t, VectorF*, VectorF*);
+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*);
@@ -93,13 +98,17 @@ 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(State);
+uint32_t     find_koptimal_fast(State);
+uint32_t     find_koptimal_gmm(State);
 
 void Init_extensions(void) {
-    VALUE ckmeans_module  = rb_const_get(rb_cObject, rb_intern("Ckmeans"));
-    VALUE clusterer_class = rb_const_get(ckmeans_module, rb_intern("Clusterer"));
+    VALUE ckmeans_module     = rb_const_get(rb_cObject, rb_intern("Ckmeans"));
+    VALUE ckmedian_module    = rb_const_get(rb_cObject, rb_intern("Ckmedian"));
+    VALUE ckmeans_clusterer  = rb_const_get(ckmeans_module, rb_intern("Clusterer"));
+    VALUE ckmedian_clusterer = rb_const_get(ckmedian_module, rb_intern("Clusterer"));
 
-    rb_define_private_method(clusterer_class, "sorted_group_sizes", rb_ckmeans_sorted_group_sizes, 0);
+    rb_define_private_method(ckmeans_clusterer, "sorted_group_sizes", rb_ckmeans_sorted_group_sizes, 0);
+    rb_define_private_method(ckmedian_clusterer, "sorted_group_sizes", rb_ckmedian_sorted_group_sizes, 0);
 }
 
 # define ARENA_MIN_CAPACITY 100
@@ -108,13 +117,23 @@ void Init_extensions(void) {
 
 VALUE rb_ckmeans_sorted_group_sizes(VALUE self)
 {
-    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 apply_deviation = RTEST(rb_iv_get(self, "@apply_bic_deviation"));
-    VALUE rb_xsorted     = rb_iv_get(self, "@xsorted");
-    size_t capacity      = sizeof(LDouble) * (xcount + 1) * (kmax + 1) * ALLOCATION_FACTOR + ARENA_MIN_CAPACITY;
-    Arena *arena         = arena_create(capacity);
+    return rb_sorted_group_sizes(self, dissimilarity_l2);
+}
+
+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");
 
@@ -130,16 +149,16 @@ VALUE rb_ckmeans_sorted_group_sizes(VALUE self)
     }
 
     State state = {
-        .arena           = arena,
-        .xcount          = xcount,
-        .kmin            = kmin,
-        .kmax            = kmax,
-        .apply_deviation = apply_deviation,
-        .xsorted         = xsorted,
-        .cost            = cost,
-        .splits          = splits,
-        .xsum            = xsum,
-        .xsumsq          = xsumsq
+        .arena   = arena,
+        .xcount  = xcount,
+        .kmin    = kmin,
+        .kmax    = kmax,
+        .xsorted = xsorted,
+        .cost    = cost,
+        .splits  = splits,
+        .xsum    = xsum,
+        .xsumsq  = xsumsq,
+        .dissim  = criteria
     };
 
 
@@ -157,7 +176,7 @@ VALUE rb_ckmeans_sorted_group_sizes(VALUE self)
 
         vector_set_f(xsum, i, xsum_prev + diff);
         vector_set_f(xsumsq, i, xsumsq_prev + diff * diff);
-        matrix_set_f(cost, 0, i, dissimilarity(0, i, xsum, xsumsq));
+        matrix_set_f(cost, 0, i, criteria(0, i, xsum, xsumsq));
         matrix_set_i(splits, 0, i, 0);
     }
 
@@ -166,7 +185,7 @@ VALUE rb_ckmeans_sorted_group_sizes(VALUE self)
         fill_row(state, q, imin, xcount - 1);
     }
 
-    uint32_t koptimal = find_koptimal(state);
+    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);
@@ -188,7 +207,7 @@ VALUE rb_ckmeans_sorted_group_sizes(VALUE self)
     return response;
 }
 
-uint32_t find_koptimal(State state)
+uint32_t find_koptimal_fast(State state)
 {
     uint32_t kmin       = state.kmin;
     uint32_t kmax       = state.kmax;
@@ -235,8 +254,7 @@ uint32_t find_koptimal(State state)
                     loglikelihood += -(xi - mean) * (xi - mean) / (2.0 * variance);
                 }
                 loglikelihood += npoints * (
-                    (state.apply_deviation ? 0.0 : log(npoints / (LDouble) xcount)) -
-                    (0.5 * log(PIx2 * variance))
+                    log(npoints / (LDouble) xcount) - (0.5 * log(PIx2 * variance))
                 );
             } else {
                 loglikelihood += npoints * log(1.0 / bin_width / xcount);
@@ -259,6 +277,101 @@ uint32_t find_koptimal(State state)
     return kopt;
 }
 
+uint32_t find_koptimal_gmm(State state)
+{
+    uint32_t kmin = state.kmin;
+    uint32_t kmax = state.kmax;
+    uint32_t xcount = state.xcount;
+
+    if (kmin > kmax || xcount < 2) {
+        return (kmin < kmax) ? kmin : kmax;
+    }
+
+    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);
+    VectorF *sigma2    = vector_create_f(arena, kmax);
+    VectorF *coeff     = vector_create_f(arena, kmax);
+    VectorI *sizes     = vector_create_i(arena, kmax);
+
+    for (uint32_t kouter = kmin; kouter <= kmax; ++kouter)
+    {
+        uint32_t ileft = 0;
+        uint32_t iright;
+
+        backtrack_sizes(state, sizes, kouter);
+
+        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;
+            SegmentStats stats = shifted_data_variance(xsorted, ileft, iright);
+
+            vector_set_f(mu, k, stats.mean);
+            vector_set_f(sigma2, k, stats.variance);
+
+            if (stats.variance == 0 || size == 1) {
+                LDouble dmin;
+
+                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);
+
+                    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);
+                }
+
+                if (stats.variance == 0) vector_set_f(sigma2, k, dmin * dmin / 4.0 / 9.0);
+                if (size == 1)  vector_set_f(sigma2, k, dmin * dmin);
+            }
+
+            LDouble lambda_k = vector_get_f(lambda, k);
+            LDouble sigma2_k = vector_get_f(sigma2, k);
+            vector_set_f(coeff, k, lambda_k / sqrt(PIx2 * sigma2_k));
+            ileft = iright + 1;
+        }
+
+        LDouble loglikelihood = 0.0;
+
+        for (uint32_t i = 0; i < xcount; ++i)
+        {
+            LDouble L  = 0.0;
+            LDouble xi = vector_get_f(xsorted, i);
+
+            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 sigma2_k  = vector_get_f(sigma2, k);
+                LDouble x_mu_diff = xi - mu_k;
+                L                += coeff_k * exp(- x_mu_diff * x_mu_diff / (2.0 * sigma2_k));
+            }
+            loglikelihood += log(L);
+        }
+
+        LDouble bic = 2 * loglikelihood - (3 * kouter - 1) * log_xcount;
+
+        if (kouter == kmin) {
+            max_bic = bic;
+            kopt = kmin;
+        } else {
+            if (bic > max_bic) {
+                max_bic = bic;
+                kopt = kouter;
+            }
+        }
+    }
+    return kopt;
+}
+
 VectorI *backtrack_sizes(State state, VectorI *sizes, uint32_t k)
 {
     MatrixI *splits = state.splits;
@@ -336,7 +449,7 @@ void smawk(State state, RowParams rparams, VectorI *split_candidates)
     }
 }
 
-void fill_even_positions(State state, RowParams rparams, VectorI *split_candidates)
+inline void fill_even_positions(State state, RowParams rparams, VectorI *split_candidates)
 {
     uint32_t row     = rparams.row;
     uint32_t imin    = rparams.imin;
@@ -345,9 +458,10 @@ void fill_even_positions(State state, RowParams rparams, VectorI *split_candidat
     uint32_t n       = split_candidates->size;
     uint32_t istepx2 = istep * 2;
     uint32_t jl      = vector_get_i(split_candidates, 0);
-    VectorF *xsum    = state.xsum;
-    VectorF *xsumsq  = state.xsumsq;
-    MatrixI *splits  = state.splits;
+    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++;
@@ -356,7 +470,7 @@ void fill_even_positions(State state, RowParams rparams, VectorI *split_candidat
         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) + dissimilarity(rcandidate, i, xsum, xsumsq);
+            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);
@@ -367,7 +481,7 @@ void fill_even_positions(State state, RowParams rparams, VectorI *split_candidat
             : vector_get_i(split_candidates, n - 1);
 
         uint32_t jmax  = jh < i ? jh : i;
-        LDouble sjimin = dissimilarity(jmax, i, xsum, xsumsq);
+        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);
@@ -376,7 +490,7 @@ void fill_even_positions(State state, RowParams rparams, VectorI *split_candidat
             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 + dissimilarity(jabs, i, xsum, xsumsq);
+            LDouble sj        = cost_base + dissim(jabs, i, xsum, xsumsq);
             LDouble cost_prev = matrix_get_f(state.cost, row, i);
 
             if (sj <= cost_prev) {
@@ -392,14 +506,15 @@ void fill_even_positions(State state, RowParams rparams, VectorI *split_candidat
     }
 }
 
-void find_min_from_candidates(State state, RowParams rparams, VectorI *split_candidates)
+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;
+    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;
 
@@ -408,7 +523,7 @@ void find_min_from_candidates(State state, RowParams rparams, VectorI *split_can
         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         = dissimilarity(optimal_split, i, state.xsum, state.xsumsq);
+        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);
@@ -421,7 +536,7 @@ void find_min_from_candidates(State state, RowParams rparams, VectorI *split_can
             if (split > i) break;
 
             LDouble split_cost =
-                matrix_get_f(cost, row - 1, split - 1) + dissimilarity(split, i, state.xsum, state.xsumsq);
+                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;
 
@@ -432,7 +547,7 @@ void find_min_from_candidates(State state, RowParams rparams, VectorI *split_can
     }
 }
 
-VectorI *prune_candidates(State state, RowParams rparams, VectorI *split_candidates)
+inline VectorI *prune_candidates(State state, RowParams rparams, VectorI *split_candidates)
 {
     uint32_t imin  = rparams.imin;
     uint32_t row   = rparams.row;
@@ -445,6 +560,7 @@ VectorI *prune_candidates(State state, RowParams rparams, VectorI *split_candida
     uint32_t left   = 0;
     uint32_t right  = 0;
     VectorI *pruned = vector_dup_i(split_candidates, state.arena);
+    FnDissim *const dissim = state.dissim;
 
     while (m > n)
     {
@@ -452,9 +568,9 @@ VectorI *prune_candidates(State state, RowParams rparams, VectorI *split_candida
         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) + dissimilarity(j, i, state.xsum, state.xsumsq);
+            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) + dissimilarity(jnext, i, state.xsum, state.xsumsq);
+            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);
@@ -484,7 +600,8 @@ VectorI *prune_candidates(State state, RowParams rparams, VectorI *split_candida
     return pruned;
 }
 
-inline LDouble dissimilarity(uint32_t j, uint32_t i, VectorF *restrict xsum, VectorF *restrict xsumsq) {
+/* 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;
@@ -501,6 +618,48 @@ inline LDouble dissimilarity(uint32_t j, uint32_t i, VectorF *restrict xsum, Vec
     return (sji > 0) ? sji : 0.0;
 }
 
+/* L1 aka Manhattan aka Median dissimilarity criteria */
+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;
+}
+
 inline VectorF *vector_create_f(Arena *arena, uint32_t size) {
     VectorF *v;
 
@@ -656,7 +815,7 @@ Arena *arena_create(size_t capacity) {
 }
 
 void *arena_alloc(Arena *arena, size_t size) {
-    size = (size + 7) & ~7;
+    size = (size + 0xf) & ~0xf;
 
     if (arena->offset + size > arena->capacity) {
         rb_raise(rb_eNoMemError, "Arena Insufficient Capacity");

data/lib/ckmeans/clusterer.rb

@@ -2,18 +2,18 @@
 
 module Ckmeans
   class Clusterer # rubocop:disable Style/Documentation
-    def initialize(entries, kmin, kmax = kmin, kestimate = :regular)
+    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)
-      @apply_bic_deviation = kestimate == :sensitive
+      @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
     end
 
     def clusters
@@ -28,5 +28,3 @@ module Ckmeans
     end
   end
 end
-
-require "ckmeans/extensions"

data/lib/ckmeans/version.rb

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

data/lib/ckmeans.rb

@@ -2,6 +2,8 @@
 
 require_relative "ckmeans/version"
 require_relative "ckmeans/clusterer"
+require_relative "ckmedian/clusterer"
+require "ckmeans/extensions"
 
 module Ckmeans
   class Error < StandardError; end

data/lib/ckmedian/clusterer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Ckmedian
+  class Clusterer # rubocop:disable Style/Documentation
+    def initialize(entries, kmin, kmax = kmin)
+      @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)
+    end
+
+    def clusters
+      @clusters ||=
+        if @unique_xcount <= 1
+          [@xsorted_original]
+        else
+          sorted_group_sizes.each_with_object([]) do |size, groups|
+            groups << @xsorted_original.shift(size)
+          end
+        end
+    end
+  end
+end

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ckmeans
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 2.0.0
 platform: ruby
 authors:
 - Vlad Lebedev
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-05-01 00:00:00.000000000 Z
+date: 2025-06-09 00:00:00.000000000 Z
 dependencies: []
 description: Repeatable clustering of unidimensional data
 email:
@@ -32,6 +33,7 @@ files:
 - lib/ckmeans.rb
 - lib/ckmeans/clusterer.rb
 - lib/ckmeans/version.rb
+- lib/ckmedian/clusterer.rb
 - sig/ckmeans.rbs
 homepage: https://github.com/vlebedeff/rb-ckmeans
 licenses:
@@ -41,6 +43,7 @@ metadata:
   homepage_uri: https://github.com/vlebedeff/rb-ckmeans
   source_code_uri: https://github.com/vlebedeff/rb-ckmeans
   changelog_uri: https://github.com/vlebedeff/rb-ckmeans/blob/main/CHANGELOG.md
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -55,7 +58,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.5
+rubygems_version: 3.4.19
+signing_key:
 specification_version: 4
 summary: Ruby implementation of Ckmeans.1d.dp
 test_files: []