ckmeans 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ad7e8c24dd367d5e6a6dd66abc529ae92079cf99d1c781a7646c929547b0e62
-  data.tar.gz: 2e338ca878eba2d250ca61fff2ea8bee44ec8387b37e12b31600edf9da2b7130
+  metadata.gz: 508f78311a643e1fa8e693e4abf1cdf6df4eb06ff09756fa534ff4a514d0f34f
+  data.tar.gz: 4ef313387c2e45df4a8afde58e429093023a555a32f4af395a8b79c048a9d98d
 SHA512:
-  metadata.gz: 8c59e1e159cc9cada8afed9e016a5d8956cfe909bb7b7d82c8d155f388fdf1924a49072d37e52065fa643a539da3a192767eddb38da95b2c2524bcc7d0a39ebd
-  data.tar.gz: f2b535377d441bc1f2ee309a5466c8231b425aa0dd9b0512aa36257defa12b3b645694ae953b2b5e3b6997c50bde796e8fa1c2f8f10d4055b1cc9cb6abcf1353
+  metadata.gz: ae0f1aff4bd6a78da04123d3728234012d0692ec22396b9529b245c8fa473343314508f053ee02ac876131b243704316948f476840d3c495d4e72eba68e095fd
+  data.tar.gz: ab95cfdacac4d9204887d4d5c5a7b85aafa3c869ec4b7a851ae994d8f15ddf096e99cb2d1691e6120a7a6bbe51cbde0524c93ad09b5811b7561c43c60a49256c

data/.ruby-version

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

data/CHANGELOG.md

@@ -1,9 +1,22 @@
 ## [Unreleased]
 
-## [1.0.1] - 2025-04-24
+## [1.0.4] - 2025-05-01
 
-- https://github.com/vlebedeff/rb-ckmeans/pull/9
-- https://github.com/vlebedeff/rb-ckmeans/pull/8
+- Simpler capacity size expression ([#14](https://github.com/vlebedeff/rb-ckmeans/pull/14))
+
+## [1.0.3] - 2025-05-01
+
+- More frugal memory allocation ([#11](https://github.com/vlebedeff/rb-ckmeans/pull/11))
+- Use `rb_iv_get` for brevity
+- Various optimizations ([#10](https://github.com/vlebedeff/rb-ckmeans/pull/10))
+- Extract `LDouble` type definition
+- Remove `ruby-prof` gem
+- Rename `nvalues` to `size`
+
+## [1.0.2] - 2025-04-24
+
+- Polish & Housekeeping ([#9](https://github.com/vlebedeff/rb-ckmeans/pull/9))
+- Fix int variable sign ([#8](https://github.com/vlebedeff/rb-ckmeans/pull/8))
 
 ## [1.0.0] - 2025-04-22
 

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,30 +101,40 @@ 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
+# define ALLOCATION_FACTOR 3
 # 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"));
     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");
-
-    Arena *arena         =
-        arena_create(
-            sizeof(LDouble) * xcount * (kmax + 4) +
-            sizeof(uint32_t) * xcount * kmax * 5 +
-            ARENA_MIN_CAPACITY
-        );
+    size_t capacity      = sizeof(LDouble) * (xcount + 1) * (kmax + 1) * ALLOCATION_FACTOR + ARENA_MIN_CAPACITY;
+    Arena *arena         = arena_create(capacity);
 
     if (arena == NULL) rb_raise(rb_eNoMemError, "Arena Memory Allocation Failed");
 
@@ -143,7 +159,8 @@ VALUE rb_ckmeans_sorted_group_sizes(VALUE self)
         .cost            = cost,
         .splits          = splits,
         .xsum            = xsum,
-        .xsumsq          = xsumsq
+        .xsumsq          = xsumsq,
+        .dissim          = criteria
     };
 
 
@@ -161,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);
     }
 
@@ -340,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;
@@ -349,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++;
@@ -360,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);
@@ -371,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);
@@ -380,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) {
@@ -396,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;
@@ -404,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;
 
@@ -412,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);
@@ -425,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;
 
@@ -436,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;
@@ -449,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)
     {
@@ -456,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);
@@ -488,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;
@@ -505,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.3"
+  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.3
+  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: []