ckmeans 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be110daab8039e8a76ccbc68808120caf3aa7b189e107d6bced6d3519e8d917c
-  data.tar.gz: 6647bce619e675a4e24f4a17ec8e5aee23280cd97d89b29433da56e122f3c932
+  metadata.gz: 5ad7e8c24dd367d5e6a6dd66abc529ae92079cf99d1c781a7646c929547b0e62
+  data.tar.gz: 2e338ca878eba2d250ca61fff2ea8bee44ec8387b37e12b31600edf9da2b7130
 SHA512:
-  metadata.gz: 54c6292bbae43afdbb4c618983c9a602ce68fec83239cf3a2f77c42fb8544fb45801d71910796db49cdf872a6151f616a711bce9c1fe537a202cae476bbb995b
-  data.tar.gz: 82d39fb2a5870a92ab579f5342de64e69a170c1d9ef31e9d5e121fb06902d3a3dba1b6a5cd4b56b432524e991e53221b78ebee7c88bbbbea868ee63ccb256d0e
+  metadata.gz: 8c59e1e159cc9cada8afed9e016a5d8956cfe909bb7b7d82c8d155f388fdf1924a49072d37e52065fa643a539da3a192767eddb38da95b2c2524bcc7d0a39ebd
+  data.tar.gz: f2b535377d441bc1f2ee309a5466c8231b425aa0dd9b0512aa36257defa12b3b645694ae953b2b5e3b6997c50bde796e8fa1c2f8f10d4055b1cc9cb6abcf1353

data/.dockerignore

@@ -0,0 +1,13 @@
+tmp
+
+# Ignore compiled extension files
+*.bundle
+*.so
+*.o
+*.dll
+
+# Ignore generated makefiles and compilation artifacts
+ext/**/Makefile
+ext/**/mkmf.log
+ext/**/*.log
+ext/**/tmp/

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## [Unreleased]
 
+## [1.0.1] - 2025-04-24
+
+- https://github.com/vlebedeff/rb-ckmeans/pull/9
+- https://github.com/vlebedeff/rb-ckmeans/pull/8
+
+## [1.0.0] - 2025-04-22
+
+- https://github.com/vlebedeff/rb-ckmeans/pull/6
+
 ## [0.1.2] - 2025-03-31
 
 - https://github.com/vlebedeff/rb-ckmeans/pull/3

data/Dockerfile

@@ -0,0 +1,11 @@
+FROM public.ecr.aws/docker/library/ruby:3.2.2
+
+RUN apt-get update && apt-get install -y build-essential ruby-dev
+
+RUN gem install bundler -v 2.6.5
+
+WORKDIR /opt/rb-ckmeans
+COPY . .
+RUN bundle install -j 12
+
+ENTRYPOINT ["bundle", "exec"]

data/ext/ckmeans/extensions.c

@@ -3,16 +3,18 @@
 #include <string.h>
 #include "ruby.h"
 
+typedef long double LDouble;
+
 typedef struct Arena {
-    uint32_t capacity;
-    uint32_t offset;
+    size_t capacity;
+    size_t offset;
     uint8_t  *buffer;
 } Arena;
 
 typedef struct MatrixF {
     uint32_t ncols;
     uint32_t nrows;
-    long double *values;
+    LDouble *values;
 } MatrixF;
 
 typedef struct MatrixI {
@@ -22,12 +24,12 @@ typedef struct MatrixI {
 } MatrixI;
 
 typedef struct VectorF {
-    uint32_t nvalues;
-    long double *values;
+    uint32_t size;
+    LDouble *values;
 } VectorF;
 
 typedef struct VectorI {
-    uint32_t nvalues;
+    uint32_t size;
     uint32_t *values;
 } VectorI;
 
@@ -52,69 +54,71 @@ typedef struct RowParams {
 } RowParams;
 
 typedef struct {
-    long double mean;
-    long double variance;
+    LDouble mean;
+    LDouble variance;
 } SegmentStats;
 
-VALUE        rb_ckmeans_sorted_group_sizes(VALUE self);
-
-Arena       *arena_create(uint32_t);
-void        *arena_alloc(Arena*, uint32_t);
-void         arena_destroy(Arena*);
-
-MatrixF     *matrix_create_f(Arena*, uint32_t, uint32_t);
-MatrixI     *matrix_create_i(Arena*, uint32_t, uint32_t);
-void         matrix_set_f(MatrixF*, uint32_t, uint32_t, long double value);
-long double  matrix_get_f(MatrixF*, uint32_t, uint32_t);
-void         matrix_inspect_f(MatrixF*);
-void         matrix_set_i(MatrixI*, uint32_t, uint32_t, uint32_t value);
-uint32_t     matrix_get_i(MatrixI*, uint32_t, uint32_t);
-void         matrix_inspect_i(MatrixI*);
-
-VectorF     *vector_create_f(Arena*, uint32_t);
-void         vector_set_f(VectorF*, uint32_t offset, long double value);
-long double  vector_get_f(VectorF*, uint32_t offset);
-long double  vector_get_diff_f(VectorF*, uint32_t, uint32_t);
-void         vector_inspect_f(VectorF*);
-VectorI     *vector_create_i(Arena*, uint32_t);
-VectorI     *vector_dup_i(VectorI*, Arena*);
-void         vector_set_i(VectorI*, uint32_t offset, uint32_t value);
-uint32_t     vector_get_i(VectorI*, uint32_t offset);
-void         vector_downsize_i(VectorI*, uint32_t);
-void         vector_inspect_i(VectorI*);
-
-long double  dissimilarity(uint32_t, uint32_t, VectorF*, VectorF*);
+VALUE rb_ckmeans_sorted_group_sizes(VALUE self);
+
+Arena *arena_create(size_t);
+void  *arena_alloc(Arena*, size_t);
+void  arena_destroy(Arena*);
+
+MatrixF  *matrix_create_f(Arena*, uint32_t, uint32_t);
+MatrixI  *matrix_create_i(Arena*, uint32_t, uint32_t);
+void     matrix_set_f(MatrixF*, uint32_t, uint32_t, LDouble value);
+LDouble  matrix_get_f(MatrixF*, uint32_t, uint32_t);
+void     matrix_inspect_f(MatrixF*);
+void     matrix_set_i(MatrixI*, uint32_t, uint32_t, uint32_t value);
+uint32_t matrix_get_i(MatrixI*, uint32_t, uint32_t);
+void     matrix_inspect_i(MatrixI*);
+
+VectorF  *vector_create_f(Arena*, uint32_t);
+void     vector_set_f(VectorF*, uint32_t offset, LDouble value);
+LDouble  vector_get_f(VectorF*, uint32_t offset);
+LDouble  vector_get_diff_f(VectorF*, uint32_t, uint32_t);
+void     vector_inspect_f(VectorF*);
+VectorI  *vector_create_i(Arena*, uint32_t);
+VectorI  *vector_dup_i(VectorI*, Arena*);
+void     vector_set_i(VectorI*, uint32_t offset, uint32_t value);
+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*);
 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*);
+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, 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 ckmeans_module  = rb_const_get(rb_cObject, rb_intern("Ckmeans"));
     VALUE clusterer_class = rb_const_get(ckmeans_module, rb_intern("Clusterer"));
 
     rb_define_private_method(clusterer_class, "sorted_group_sizes", rb_ckmeans_sorted_group_sizes, 0);
 }
 
-# define ARENA_MIN_CAPACITY 1024
-# define ALLOCATION_FACTOR 20
+# define ARENA_MIN_CAPACITY 100
 # define PIx2 (M_PI * 2.0)
 
-VALUE rb_ckmeans_sorted_group_sizes(VALUE self) {
-    VALUE rb_xcount              = rb_ivar_get(self, rb_intern("@xcount"));
-    VALUE rb_kmin                = rb_ivar_get(self, rb_intern("@kmin"));
-    VALUE rb_kmax                = rb_ivar_get(self, rb_intern("@kmax"));
-    VALUE rb_xsorted             = rb_ivar_get(self, rb_intern("@xsorted"));
-    VALUE rb_apply_bic_deviation = rb_ivar_get(self, rb_intern("@apply_bic_deviation"));
-    uint32_t xcount              = NUM2UINT(rb_xcount);
-    uint32_t kmin                = NUM2UINT(rb_kmin);
-    uint32_t kmax                = NUM2UINT(rb_kmax);
-    bool apply_deviation         = RTEST(rb_apply_bic_deviation);
-    Arena *arena                 = arena_create(sizeof(int) * xcount * kmax * ALLOCATION_FACTOR);
+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");
+
+    Arena *arena         =
+        arena_create(
+            sizeof(LDouble) * xcount * (kmax + 4) +
+            sizeof(uint32_t) * xcount * kmax * 5 +
+            ARENA_MIN_CAPACITY
+        );
 
     if (arena == NULL) rb_raise(rb_eNoMemError, "Arena Memory Allocation Failed");
 
@@ -125,7 +129,7 @@ VALUE rb_ckmeans_sorted_group_sizes(VALUE self) {
     VectorF *xsumsq  = vector_create_f(arena, xcount);
 
     for (uint32_t i = 0; i < xcount; i++) {
-        long double xi = NUM2DBL(rb_ary_entry(rb_xsorted, i));
+        LDouble xi = NUM2DBL(rb_ary_entry(rb_xsorted, i));
         vector_set_f(xsorted, i, xi);
     }
 
@@ -143,17 +147,17 @@ VALUE rb_ckmeans_sorted_group_sizes(VALUE self) {
     };
 
 
-    long double shift        = vector_get_f(xsorted, xcount / 2);
-    long double diff_initial = vector_get_f(xsorted, 0) - shift;
+    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++) {
-        long double xi          = vector_get_f(xsorted, i);
-        long double xsum_prev   = vector_get_f(xsum, i - 1);
-        long double xsumsq_prev = vector_get_f(xsumsq, i - 1);
-        long double diff        = xi - shift;
+        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);
@@ -168,7 +172,8 @@ VALUE rb_ckmeans_sorted_group_sizes(VALUE self) {
 
     uint32_t koptimal = find_koptimal(state);
 
-    VectorI *sizes = backtrack_sizes(state, koptimal);
+    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); */
@@ -176,8 +181,8 @@ VALUE rb_ckmeans_sorted_group_sizes(VALUE self) {
     /* printf("FINAL COST\n"); matrix_inspect_f(cost); */
     /* printf("FINAL SPLITS\n"); matrix_inspect_i(splits); */
 
-    VALUE response = rb_ary_new2(sizes->nvalues);
-    for (uint32_t i = 0; i < sizes->nvalues; i++) {
+    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);
     }
@@ -189,29 +194,30 @@ VALUE rb_ckmeans_sorted_group_sizes(VALUE self) {
 
 uint32_t find_koptimal(State state)
 {
-    uint32_t kmin          = state.kmin;
-    uint32_t kmax          = state.kmax;
-    uint32_t xcount        = state.xcount;
-    uint32_t kopt          = kmin;
-    uint32_t xindex_max    = state.xcount - 1;
-    VectorF *xsorted       = state.xsorted;
-    long double x0         = vector_get_f(xsorted, 0);
-    long double xn         = vector_get_f(xsorted, xindex_max);
-    long double max_bic    = 0.0;
-    long double adjustment = state.apply_deviation ? 0.0 : 1.0;
-
+    uint32_t kmin       = state.kmin;
+    uint32_t kmax       = state.kmax;
+    uint32_t xcount     = state.xcount;
+    uint32_t kopt       = kmin;
+    uint32_t xindex_max = state.xcount - 1;
+    VectorF *xsorted    = state.xsorted;
+    LDouble x0          = vector_get_f(xsorted, 0);
+    LDouble xn          = vector_get_f(xsorted, xindex_max);
+    LDouble max_bic     = 0.0;
+    LDouble xcount_log  = log((LDouble) xcount);
+
+    VectorI *sizes = vector_create_i(state.arena, kmax);
     for (uint32_t k = kmin; k <= kmax; k++) {
         uint32_t index_right, index_left = 0;
-        long double bin_left, bin_right, loglikelihood = 0.0;
-        VectorI *sizes = backtrack_sizes(state, k);
+        LDouble bin_left, bin_right, loglikelihood = 0.0;
+        backtrack_sizes(state, sizes, k);
 
         for (uint32_t kb = 0; kb < k; kb++) {
-            uint32_t npoints   = vector_get_i(sizes, kb);
-            index_right        = index_left + npoints - 1;
-            long double xleft  = vector_get_f(xsorted, index_left);
-            long double xright = vector_get_f(xsorted, index_right);
-            bin_left           = xleft;
-            bin_right          = xright;
+            uint32_t npoints = vector_get_i(sizes, kb);
+            index_right      = index_left + npoints - 1;
+            LDouble xleft    = vector_get_f(xsorted, index_left);
+            LDouble xright   = vector_get_f(xsorted, index_right);
+            bin_left         = xleft;
+            bin_right        = xright;
 
             if (xleft == xright) {
                 bin_left  = index_left == 0
@@ -222,18 +228,18 @@ uint32_t find_koptimal(State state)
                     : xn;
             }
 
-            long double bin_width = bin_right - bin_left;
-            SegmentStats stats    = shifted_data_variance(xsorted, index_left, index_right);
-            long double mean      = stats.mean;
-            long double variance  = stats.variance;
+            LDouble bin_width  = bin_right - bin_left;
+            SegmentStats stats = shifted_data_variance(xsorted, index_left, index_right);
+            LDouble mean       = stats.mean;
+            LDouble variance   = stats.variance;
 
             if (variance > 0) {
                 for (uint32_t i = index_left; i <= index_right; i++) {
-                    long double xi = vector_get_f(xsorted, i);
+                    LDouble xi     = vector_get_f(xsorted, i);
                     loglikelihood += -(xi - mean) * (xi - mean) / (2.0 * variance);
                 }
                 loglikelihood += npoints * (
-                    (log(npoints / (long double) xcount) * adjustment) -
+                    (state.apply_deviation ? 0.0 : log(npoints / (LDouble) xcount)) -
                     (0.5 * log(PIx2 * variance))
                 );
             } else {
@@ -243,24 +249,23 @@ uint32_t find_koptimal(State state)
             index_left = index_right + 1;
         }
 
-        long double bic = (2.0 * loglikelihood) - (((3 * k) - 1) * log((long double) xcount));
+        LDouble bic = (2.0 * loglikelihood) - (((3 * k) - 1) * xcount_log);
 
         if (k == kmin) {
             max_bic = bic;
-            kopt = kmin;
+            kopt    = kmin;
         } else if (bic > max_bic) {
             max_bic = bic;
-            kopt = k;
+            kopt    = k;
         }
     }
 
     return kopt;
 }
 
-VectorI *backtrack_sizes(State state, uint32_t k)
+VectorI *backtrack_sizes(State state, VectorI *sizes, uint32_t k)
 {
     MatrixI *splits = state.splits;
-    VectorI *sizes  = vector_create_i(state.arena, k);
     uint32_t xcount = state.xcount;
     uint32_t right  = xcount - 1;
     uint32_t left   = 0;
@@ -280,15 +285,15 @@ VectorI *backtrack_sizes(State state, uint32_t k)
 SegmentStats shifted_data_variance(VectorF *xsorted, uint32_t left, uint32_t right)
 {
     const uint32_t n   = right - left + 1;
-    long double sum    = 0.0;
-    long double sumsq  = 0.0;
+    LDouble sum        = 0.0;
+    LDouble sumsq      = 0.0;
     SegmentStats stats = { .mean = 0.0, .variance = 0.0 };
 
     if (right >= left) {
-        const long double median = vector_get_f(xsorted, (left + right) / 2);
+        const LDouble median = vector_get_f(xsorted, (left + right) / 2);
 
         for (uint32_t i = left; i <= right; i++) {
-            const long double sumi = vector_get_f(xsorted, i) - median;
+            const LDouble sumi = vector_get_f(xsorted, i) - median;
 
             sum   += sumi;
             sumsq += sumi * sumi;
@@ -341,7 +346,7 @@ void fill_even_positions(State state, RowParams rparams, VectorI *split_candidat
     uint32_t imin    = rparams.imin;
     uint32_t imax    = rparams.imax;
     uint32_t istep   = rparams.istep;
-    uint32_t n       = split_candidates->nvalues;
+    uint32_t n       = split_candidates->size;
     uint32_t istepx2 = istep * 2;
     uint32_t jl      = vector_get_i(split_candidates, 0);
     VectorF *xsum    = state.xsum;
@@ -351,22 +356,22 @@ void fill_even_positions(State state, RowParams rparams, VectorI *split_candidat
     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 rcandidate    = vector_get_i(split_candidates, r);
         uint32_t cost_base_row = row - 1;
         uint32_t cost_base_col = rcandidate - 1;
-        long double cost      =
+        LDouble cost           =
             matrix_get_f(state.cost, cost_base_row, cost_base_col) + dissimilarity(rcandidate, i, xsum, xsumsq);
 
         matrix_set_f(state.cost, row, i, cost);
         matrix_set_i(state.splits, row, i, rcandidate);
 
-        uint32_t jh         =
+        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;
-        long double sjimin = dissimilarity(jmax, i, xsum, xsumsq);
+        uint32_t jmax  = jh < i ? jh : i;
+        LDouble sjimin = dissimilarity(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);
@@ -374,9 +379,9 @@ void fill_even_positions(State state, RowParams rparams, VectorI *split_candidat
             if (jabs > i) break;
             if (jabs < matrix_get_i(splits, row - 1, i)) continue;
 
-            long double cost_base = matrix_get_f(state.cost, row - 1, jabs  - 1);
-            long double sj        = cost_base + dissimilarity(jabs, i, xsum, xsumsq);
-            long double cost_prev = matrix_get_f(state.cost, row, i);
+            LDouble cost_base = matrix_get_f(state.cost, row - 1, jabs  - 1);
+            LDouble sj        = cost_base + dissimilarity(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);
@@ -407,19 +412,19 @@ 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 long double added_cost     = dissimilarity(optimal_split, i, state.xsum, state.xsumsq);
+        const LDouble added_cost         = dissimilarity(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->nvalues; r++)
+        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;
 
-            long double split_cost =
+            LDouble split_cost =
                 matrix_get_f(cost, row - 1, split - 1) + dissimilarity(split, i, state.xsum, state.xsumsq);
 
             if (split_cost > matrix_get_f(cost, row, i)) continue;
@@ -437,7 +442,7 @@ VectorI *prune_candidates(State state, RowParams rparams, VectorI *split_candida
     uint32_t row   = rparams.row;
     uint32_t istep = rparams.istep;
     uint32_t n     = ((rparams.imax - imin) / istep) + 1;
-    uint32_t m     = split_candidates->nvalues;
+    uint32_t m     = split_candidates->size;
 
     if (n >= m) return split_candidates;
 
@@ -447,12 +452,12 @@ VectorI *prune_candidates(State state, RowParams rparams, VectorI *split_candida
 
     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);
-        long double sl    =
+        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) + dissimilarity(j, i, state.xsum, state.xsumsq);
-        long double snext =
+        LDouble snext  =
             matrix_get_f(state.cost, row - 1, jnext - 1) + dissimilarity(jnext, i, state.xsum, state.xsumsq);
 
         if ((sl < snext) && (left < n - 1)) {
@@ -483,86 +488,86 @@ VectorI *prune_candidates(State state, RowParams rparams, VectorI *split_candida
     return pruned;
 }
 
-long double dissimilarity(uint32_t j, uint32_t i, VectorF *xsum, VectorF *xsumsq) {
-    long double sji = 0.0;
+inline LDouble dissimilarity(uint32_t j, uint32_t i, VectorF *restrict xsum, VectorF *restrict xsumsq) {
+    LDouble sji = 0.0;
 
     if (j >= i) return sji;
 
     if (j > 0) {
-        long double 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);
+        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 {
-        long double xsumi = vector_get_f(xsum, i);
-        sji               = vector_get_f(xsumsq, i) - (xsumi * xsumi / (i + 1));
+        LDouble xsumi = vector_get_f(xsum, i);
+        sji           = vector_get_f(xsumsq, i) - (xsumi * xsumi / (i + 1));
     }
 
     return (sji > 0) ? sji : 0.0;
 }
 
-VectorF *vector_create_f(Arena *arena, uint32_t nvalues) {
+inline VectorF *vector_create_f(Arena *arena, uint32_t size) {
     VectorF *v;
 
-    v          = arena_alloc(arena, sizeof(*v));
-    v->values  = arena_alloc(arena, sizeof(*(v->values)) * nvalues);
-    v->nvalues = nvalues;
+    v         = arena_alloc(arena, sizeof(*v));
+    v->values = arena_alloc(arena, sizeof(*(v->values)) * size);
+    v->size   = size;
 
     return v;
 }
 
-VectorI *vector_create_i(Arena *arena, uint32_t nvalues) {
+inline VectorI *vector_create_i(Arena *arena, uint32_t size) {
     VectorI *v;
 
-    v          = arena_alloc(arena, sizeof(*v));
-    v->values  = arena_alloc(arena, sizeof(*(v->values)) * nvalues);
-    v->nvalues = nvalues;
+    v         = arena_alloc(arena, sizeof(*v));
+    v->values = arena_alloc(arena, sizeof(*(v->values)) * size);
+    v->size   = size;
 
     return v;
 }
 
-VectorI *vector_dup_i(VectorI *v, Arena *arena)
+inline VectorI *vector_dup_i(VectorI *v, Arena *arena)
 {
-    VectorI *vdup = vector_create_i(arena, v->nvalues);
+    VectorI *vdup = vector_create_i(arena, v->size);
 
-    memcpy(vdup->values, v->values, sizeof(*(v->values)) * v->nvalues);
+    memcpy(vdup->values, v->values, sizeof(*(v->values)) * v->size);
 
     return vdup;
 }
 
-void vector_set_f(VectorF *v, uint32_t offset, long double value) {
+inline void vector_set_f(VectorF *v, uint32_t offset, LDouble value) {
     *(v->values + offset) = value;
 }
 
-void vector_set_i(VectorI *v, uint32_t offset, uint32_t value) {
+inline void vector_set_i(VectorI *v, uint32_t offset, uint32_t value) {
     *(v->values + offset) = value;
 }
 
-uint32_t vector_get_i(VectorI *v, uint32_t offset) {
+inline uint32_t vector_get_i(VectorI *v, uint32_t offset) {
     return *(v->values + offset);
 }
 
-void vector_downsize_i(VectorI *v, uint32_t new_size) {
-    v->nvalues = new_size;
+inline void vector_downsize_i(VectorI *v, uint32_t new_size) {
+    v->size = new_size;
 }
 
 void vector_inspect_i(VectorI *v) {
-    for (uint32_t i = 0; i < v->nvalues - 1; i++)
+    for (uint32_t i = 0; i < v->size - 1; i++)
         printf("%u, ", vector_get_i(v, i));
-    printf("%u\n", vector_get_i(v, v->nvalues - 1));
+    printf("%u\n", vector_get_i(v, v->size - 1));
 }
 
-long double vector_get_f(VectorF *v, uint32_t offset) {
+inline LDouble vector_get_f(VectorF *v, uint32_t offset) {
     return *(v->values + offset);
 }
 
-long double vector_get_diff_f(VectorF *v, uint32_t i, uint32_t j) {
+inline LDouble vector_get_diff_f(VectorF *v, uint32_t i, uint32_t j) {
     return *(v->values + i) - *(v->values + j);
 }
 
 void vector_inspect_f(VectorF *v) {
-    for (uint32_t i = 0; i < v->nvalues - 1; i++)
+    for (uint32_t i = 0; i < v->size - 1; i++)
         printf("%Lf, ", vector_get_f(v, i));
-    printf("%Lf\n", vector_get_f(v, v->nvalues - 1));
+    printf("%Lf\n", vector_get_f(v, v->size - 1));
 }
 
 MatrixF *matrix_create_f(Arena *arena, uint32_t nrows, uint32_t ncols) {
@@ -587,12 +592,12 @@ MatrixI *matrix_create_i(Arena *arena, uint32_t nrows, uint32_t ncols) {
     return m;
 }
 
-void matrix_set_f(MatrixF *m, uint32_t i, uint32_t j, long double value) {
+inline void matrix_set_f(MatrixF *m, uint32_t i, uint32_t j, LDouble value) {
     uint32_t offset = i * m->ncols + j;
     *(m->values + offset) = value;
 }
 
-long double matrix_get_f(MatrixF *m, uint32_t i, uint32_t j) {
+inline LDouble matrix_get_f(MatrixF *m, uint32_t i, uint32_t j) {
     uint32_t offset = i * m->ncols + j;
     return *(m->values + offset);
 }
@@ -600,7 +605,7 @@ long double matrix_get_f(MatrixF *m, uint32_t i, uint32_t j) {
 void matrix_inspect_f(MatrixF *m) {
     for (uint32_t i = 0; i < m->nrows; i++) {
         for (uint32_t j = 0; j < m->ncols - 1; j++) {
-            long double value = matrix_get_f(m, i, j);
+            LDouble value = matrix_get_f(m, i, j);
 
             printf("%Lf, ", value);
         }
@@ -616,17 +621,17 @@ void matrix_inspect_i(MatrixI *m) {
     }
 }
 
-void matrix_set_i(MatrixI *m, uint32_t i, uint32_t j, uint32_t value) {
+inline void matrix_set_i(MatrixI *m, uint32_t i, uint32_t j, uint32_t value) {
     uint32_t offset = i * m->ncols + j;
     *(m->values + offset) = value;
 }
 
-uint32_t matrix_get_i(MatrixI *m, uint32_t i, uint32_t j) {
+inline uint32_t matrix_get_i(MatrixI *m, uint32_t i, uint32_t j) {
     uint32_t offset = i * m->ncols + j;
     return *(m->values + offset);
 }
 
-Arena *arena_create(uint32_t capacity) {
+Arena *arena_create(size_t capacity) {
     if (capacity < ARENA_MIN_CAPACITY) {
         capacity = ARENA_MIN_CAPACITY;
     }
@@ -654,7 +659,7 @@ Arena *arena_create(uint32_t capacity) {
     return arena;
 }
 
-void *arena_alloc(Arena *arena, uint32_t size) {
+void *arena_alloc(Arena *arena, size_t size) {
     size = (size + 7) & ~7;
 
     if (arena->offset + size > arena->capacity) {
@@ -669,7 +674,8 @@ void *arena_alloc(Arena *arena, uint32_t size) {
 }
 
 void arena_destroy(Arena *arena) {
-    /* printf("[Arena Destroy] Capacity: %u, offset: %u, left: %u\n", arena->capacity, arena->offset, arena->capacity - arena->offset); */
+    /* double leftover = ((double) arena->capacity - arena->offset) / arena->capacity * 100; */
+    /* printf("[Arena Destroy] Capacity: %zu, offset: %zu, left: %2.2f%%\n", arena->capacity, arena->offset, leftover); */
     free(arena->buffer);
     free(arena);
 }

data/lib/ckmeans/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ckmeans
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Vlad Lebedev
 bindir: exe
 cert_chain: []
-date: 2025-04-24 00:00:00.000000000 Z
+date: 2025-05-01 00:00:00.000000000 Z
 dependencies: []
 description: Repeatable clustering of unidimensional data
 email:
@@ -17,11 +17,13 @@ extensions:
 - ext/ckmeans/extconf.rb
 extra_rdoc_files: []
 files:
+- ".dockerignore"
 - ".rspec"
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
 - ".ruby-version"
 - CHANGELOG.md
+- Dockerfile
 - LICENSE
 - README.md
 - Rakefile