ckmeans 1.0.4 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17dd59ae47e814d5cf0b45665856a52e33e1af22c90722955750004405633a4e
-  data.tar.gz: 4278bb18d8a987ac71fd7ea179055ab6d2c15292d772b7d9df1dd8c4adde011b
+  metadata.gz: 508f78311a643e1fa8e693e4abf1cdf6df4eb06ff09756fa534ff4a514d0f34f
+  data.tar.gz: 4ef313387c2e45df4a8afde58e429093023a555a32f4af395a8b79c048a9d98d
 SHA512:
-  metadata.gz: 7e3d19cfbfbebb0b26bf1ffdd7c99998a898ccf123359994e339147735b819f3f16fc73c2ac202a3fbe3c4f1c13c747e7181d01d56770be5404ca6354533b23d
-  data.tar.gz: 2be82db12f8d9da2cafb03713440f3083d2ffd7fd7f6917ad8e98d1c864b1d97f99e9a0771afe6aaaff502fee86d81e9221b8d689a388817b060fc7ce1917a87
+  metadata.gz: ae0f1aff4bd6a78da04123d3728234012d0692ec22396b9529b245c8fa473343314508f053ee02ac876131b243704316948f476840d3c495d4e72eba68e095fd
+  data.tar.gz: ab95cfdacac4d9204887d4d5c5a7b85aafa3c869ec4b7a851ae994d8f15ddf096e99cb2d1691e6120a7a6bbe51cbde0524c93ad09b5811b7561c43c60a49256c

data/.ruby-version

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

data/README.md

@@ -19,9 +19,16 @@ gem install ckmeans
 ## Usage
 
 ```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
+# Fixed cluster count
+Ckmeans::Clusterer(data, kmin).clusters
+Ckmedian::Clusterer(data, kmin).clusters
+
+# Estimate optimal cluster count within kmin and kmax
+Ckmeans::Clusterer(data, kmin, kmax).clusters
+Ckmedian::Clusterer(data, kmin, kmax).clusters
+
+# Adjust Bayesian Information Criteria favoring more smaller clusters (Ckmeans only)
+Ckmeans::Clusterer(data, kmin, kmax, :sensitive).clusters
 ```
 
 ## License

data/ext/ckmeans/extensions.c

@@ -33,6 +33,8 @@ 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;
@@ -44,6 +46,7 @@ typedef struct State {
     MatrixI *splits;
     VectorF *xsum;
     VectorF *xsumsq;
+    FnDissim *dissim;
 } State;
 
 typedef struct RowParams {
@@ -59,6 +62,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 +90,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*);
@@ -95,11 +101,15 @@ SegmentStats shifted_data_variance(VectorF*, uint32_t, uint32_t);
 VectorI      *backtrack_sizes(State, VectorI*, uint32_t);
 uint32_t     find_koptimal(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
@@ -107,6 +117,16 @@ void Init_extensions(void) {
 # define PIx2 (M_PI * 2.0)
 
 VALUE rb_ckmeans_sorted_group_sizes(VALUE self)
+{
+    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"));
@@ -139,7 +159,8 @@ VALUE rb_ckmeans_sorted_group_sizes(VALUE self)
         .cost            = cost,
         .splits          = splits,
         .xsum            = xsum,
-        .xsumsq          = xsumsq
+        .xsumsq          = xsumsq,
+        .dissim          = criteria
     };
 
 
@@ -157,7 +178,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);
     }
 
@@ -336,7 +357,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 +366,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 +378,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 +389,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 +398,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,7 +414,7 @@ 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;
@@ -400,6 +422,7 @@ void find_min_from_candidates(State state, RowParams rparams, VectorI *split_can
     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 +431,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 +444,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 +455,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 +468,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 +476,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 +508,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 +526,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;
 

data/lib/ckmeans/clusterer.rb

@@ -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 = "1.1.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: 1.1.0
 platform: ruby
 authors:
 - Vlad Lebedev
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-05-01 00:00:00.000000000 Z
+date: 2025-05-23 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: []