ckmeans 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3646d5dfdbc85e6168c9b315a52d7b345432f1b964ab96f1dd18bd04c62f867c
-  data.tar.gz: 562d6aaeff0d81b1ff804886870ed09df1d0115867f9127b8a9b8283be638e11
+  metadata.gz: be110daab8039e8a76ccbc68808120caf3aa7b189e107d6bced6d3519e8d917c
+  data.tar.gz: 6647bce619e675a4e24f4a17ec8e5aee23280cd97d89b29433da56e122f3c932
 SHA512:
-  metadata.gz: bca50713fcd779e6d2fb7bd37b44cd7ed16a4879736139f531a37f99666f4c797bae5b27b574e26fb6fffdd616ded97a397b29ac1d6e8e268e63eae073051de1
-  data.tar.gz: 167e1865fb1707b054a13f0dcabfcd8bde2ed19811886fb312a54d129b136a8c4663b961e220097fbede697f02a58c1e72de3ec0640c33aadba6b59e404c0acb
+  metadata.gz: 54c6292bbae43afdbb4c618983c9a602ce68fec83239cf3a2f77c42fb8544fb45801d71910796db49cdf872a6151f616a711bce9c1fe537a202cae476bbb995b
+  data.tar.gz: 82d39fb2a5870a92ab579f5342de64e69a170c1d9ef31e9d5e121fb06902d3a3dba1b6a5cd4b56b432524e991e53221b78ebee7c88bbbbea868ee63ccb256d0e

data/.rubocop_todo.yml

@@ -1,49 +1,13 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2025-04-17 07:09:28 UTC using RuboCop version 1.75.1.
+# on 2025-04-24 06:16:37 UTC using RuboCop version 1.75.1.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
 # versions of RuboCop, may require this file to be generated again.
 
-# Offense count: 7
-# Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes.
-Metrics/AbcSize:
-  Max: 95
-
-# Offense count: 2
+# Offense count: 1
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 # AllowedMethods: refine
 Metrics/BlockLength:
-  Max: 41
-
-# Offense count: 3
-# Configuration parameters: AllowedMethods, AllowedPatterns.
-Metrics/CyclomaticComplexity:
-  Max: 10
-
-# Offense count: 6
-# Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
-Metrics/MethodLength:
-  Max: 48
-
-# Offense count: 3
-# Configuration parameters: AllowedMethods, AllowedPatterns.
-Metrics/PerceivedComplexity:
-  Max: 13
-
-# Offense count: 12
-# Configuration parameters: MinNameLength, AllowNamesEndingInNumbers, AllowedNames, ForbiddenNames.
-# AllowedNames: as, at, by, cc, db, id, if, in, io, ip, of, on, os, pp, to
-Naming/MethodParameterName:
-  Exclude:
-    - 'lib/ckmeans/clusterer.rb'
-
-# Offense count: 5
-# This cop supports unsafe autocorrection (--autocorrect-all).
-# Configuration parameters: EnforcedStyle, AllowedMethods, AllowedPatterns.
-# SupportedStyles: predicate, comparison
-Style/NumericPredicate:
-  Exclude:
-    - 'spec/**/*'
-    - 'lib/ckmeans/clusterer.rb'
+  Max: 26

data/ext/ckmeans/extensions.c

@@ -1,6 +1,6 @@
 #include <stdio.h>
-#include <assert.h>
 #include <math.h>
+#include <string.h>
 #include "ruby.h"
 
 typedef struct Arena {
@@ -60,7 +60,6 @@ VALUE        rb_ckmeans_sorted_group_sizes(VALUE self);
 
 Arena       *arena_create(uint32_t);
 void        *arena_alloc(Arena*, uint32_t);
-void         arena_rewind(Arena*);
 void         arena_destroy(Arena*);
 
 MatrixF     *matrix_create_f(Arena*, uint32_t, uint32_t);
@@ -117,14 +116,11 @@ VALUE rb_ckmeans_sorted_group_sizes(VALUE self) {
     bool apply_deviation         = RTEST(rb_apply_bic_deviation);
     Arena *arena                 = arena_create(sizeof(int) * xcount * kmax * ALLOCATION_FACTOR);
 
-    if (arena == NULL) {
-        return Qnil;
-    }
+    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);
-    /* TODO: pack sums into one vector of pairs */
     VectorF *xsum    = vector_create_f(arena, xcount);
     VectorF *xsumsq  = vector_create_f(arena, xcount);
 
@@ -193,11 +189,11 @@ 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;
+    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);
@@ -274,6 +270,7 @@ VectorI *backtrack_sizes(State state, uint32_t k)
         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);
 
@@ -282,7 +279,7 @@ 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;
+    const uint32_t n   = right - left + 1;
     long double sum    = 0.0;
     long double sumsq  = 0.0;
     SegmentStats stats = { .mean = 0.0, .variance = 0.0 };
@@ -306,7 +303,8 @@ SegmentStats shifted_data_variance(VectorF *xsorted, uint32_t left, uint32_t rig
     return stats;
 }
 
-void fill_row(State state, uint32_t q, uint32_t imin, uint32_t imax) {
+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++) {
@@ -316,7 +314,8 @@ void fill_row(State state, uint32_t q, uint32_t imin, uint32_t imax) {
     smawk(state, rparams, split_candidates);
 }
 
-void smawk(State state, RowParams rparams, VectorI *split_candidates) {
+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;
@@ -326,9 +325,9 @@ void smawk(State state, RowParams rparams, VectorI *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);
+        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);
@@ -345,9 +344,9 @@ void fill_even_positions(State state, RowParams rparams, VectorI *split_candidat
     uint32_t n       = split_candidates->nvalues;
     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 *xsum    = state.xsum;
+    VectorF *xsumsq  = state.xsumsq;
+    MatrixI *splits  = state.splits;
 
     for (uint32_t i = imin, r = 0; i <= imax; i += istepx2) {
         while (vector_get_i(split_candidates, r) < jl) r++;
@@ -394,10 +393,10 @@ void fill_even_positions(State state, RowParams rparams, VectorI *split_candidat
 
 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;
+    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;
 
@@ -408,7 +407,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 long double added_cost    = dissimilarity(optimal_split, i, state.xsum, state.xsumsq);
+        const long double 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);
@@ -434,39 +433,39 @@ void find_min_from_candidates(State state, RowParams rparams, VectorI *split_can
 
 VectorI *prune_candidates(State state, RowParams rparams, VectorI *split_candidates)
 {
-    uint32_t n = ((rparams.imax - rparams.imin) / rparams.istep) + 1;
-    uint32_t m = split_candidates->nvalues;
+    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->nvalues;
 
     if (n >= m) return split_candidates;
 
-    int32_t left    = -1;
+    uint32_t left   = 0;
     uint32_t right  = 0;
     VectorI *pruned = vector_dup_i(split_candidates, state.arena);
 
     while (m > n)
     {
-        uint32_t p         = left + 1;
-        uint32_t i         = rparams.imin + p * rparams.istep;
-        uint32_t j         = vector_get_i(pruned, right);
-        uint32_t jnext     = vector_get_i(pruned, right + 1);
+        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    =
-            matrix_get_f(state.cost, rparams.row - 1, j - 1) + dissimilarity(j, i, state.xsum, state.xsumsq);
+            matrix_get_f(state.cost, row - 1, j - 1) + dissimilarity(j, i, state.xsum, state.xsumsq);
         long double snext =
-            matrix_get_f(state.cost, rparams.row - 1, jnext - 1) + dissimilarity(jnext, i, state.xsum, state.xsumsq);
+            matrix_get_f(state.cost, row - 1, jnext - 1) + dissimilarity(jnext, i, state.xsum, state.xsumsq);
 
-        if ((sl < snext) && (p < n - 1)) {
+        if ((sl < snext) && (left < n - 1)) {
+            vector_set_i(pruned, left, j);
             left++;
             right++;
-            vector_set_i(pruned, left, j);
-        } else if ((sl < snext) && (p == n - 1)) {
+        } else if ((sl < snext) && (left == n - 1)) {
             right++;
             m--;
             vector_set_i(pruned, right, j);
         } else {
-            if (p > 0) {
-                /* TODO: extract `vector_setcpy_T` */
-                vector_set_i(pruned, right, vector_get_i(pruned, left));
-                left--;
+            if (left > 0) {
+                vector_set_i(pruned, right, vector_get_i(pruned, --left));
             } else {
                 right++;
             }
@@ -475,8 +474,7 @@ VectorI *prune_candidates(State state, RowParams rparams, VectorI *split_candida
         }
     }
 
-    for (uint32_t i = left + 1; i < m; i++) {
-        /* TODO: extract `vector_setcpy_T` */
+    for (uint32_t i = left; i < m; i++) {
         vector_set_i(pruned, i, vector_get_i(pruned, right++));
     }
 
@@ -491,10 +489,9 @@ long double dissimilarity(uint32_t j, uint32_t i, VectorF *xsum, VectorF *xsumsq
     if (j >= i) return sji;
 
     if (j > 0) {
-        /* TODO: looks more like `segment_delta` */
-        long double segment_sum = vector_get_diff_f(xsum, i, j - 1);
+        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_sum * segment_sum / segment_size);
+        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));
@@ -527,29 +524,20 @@ VectorI *vector_dup_i(VectorI *v, Arena *arena)
 {
     VectorI *vdup = vector_create_i(arena, v->nvalues);
 
-    /* TODO: use one memcpy call */
-    for (uint32_t i = 0; i < v->nvalues; i++) {
-        vector_set_i(vdup, i, vector_get_i(v, i));
-    }
+    memcpy(vdup->values, v->values, sizeof(*(v->values)) * v->nvalues);
 
     return vdup;
 }
 
 void vector_set_f(VectorF *v, uint32_t offset, long double value) {
-    assert(offset < v->nvalues && "[vector_set_f] element index should be less than nvalues");
-
     *(v->values + offset) = value;
 }
 
 void vector_set_i(VectorI *v, uint32_t offset, uint32_t value) {
-    assert(offset < v->nvalues && "[vector_set_i] element index should be less than nvalues");
-
     *(v->values + offset) = value;
 }
 
 uint32_t vector_get_i(VectorI *v, uint32_t offset) {
-    assert(offset < v->nvalues && "[vector_get_i] element index should be less than nvalues");
-
     return *(v->values + offset);
 }
 
@@ -564,15 +552,10 @@ void vector_inspect_i(VectorI *v) {
 }
 
 long double vector_get_f(VectorF *v, uint32_t offset) {
-    assert(offset < v->nvalues && "[vector_get_f] element index should be less than nvalues");
-
     return *(v->values + offset);
 }
 
 long double vector_get_diff_f(VectorF *v, uint32_t i, uint32_t j) {
-    assert(i < v->nvalues && "[vector_get_diff_f] i should be less than nvalues");
-    assert(j < v->nvalues && "[vector_get_diff_f] j should be less than nvalues");
-
     return *(v->values + i) - *(v->values + j);
 }
 
@@ -605,17 +588,11 @@ MatrixI *matrix_create_i(Arena *arena, uint32_t nrows, uint32_t ncols) {
 }
 
 void matrix_set_f(MatrixF *m, uint32_t i, uint32_t j, long double value) {
-    assert(i < m->nrows && "[matrix_set_f] row offset should be less than nrows");
-    assert(j < m->cols &&  "[matrix_set_f] col offset should be less than ncols");
-
     uint32_t offset = i * m->ncols + j;
     *(m->values + offset) = value;
 }
 
 long double matrix_get_f(MatrixF *m, uint32_t i, uint32_t j) {
-    assert(i < m->nrows && "[matrix_get_f] row offset should be less than nrows");
-    assert(j < m->cols &&  "[matrix_get_f] col offset should be less than ncols");
-
     uint32_t offset = i * m->ncols + j;
     return *(m->values + offset);
 }
@@ -640,17 +617,11 @@ void matrix_inspect_i(MatrixI *m) {
 }
 
 void matrix_set_i(MatrixI *m, uint32_t i, uint32_t j, uint32_t value) {
-    assert(i < m->nrows && "[matrix_set_i] row offset should be less than nrows");
-    assert(j < m->cols &&  "[matrix_set_i] col offset should be less than ncols");
-
     uint32_t offset = i * m->ncols + j;
     *(m->values + offset) = value;
 }
 
 uint32_t matrix_get_i(MatrixI *m, uint32_t i, uint32_t j) {
-    assert(i < m->nrows && "[matrix_get_i] row offset should be less than nrows");
-    assert(j < m->cols &&  "[matrix_get_i] col offset should be less than ncols");
-
     uint32_t offset = i * m->ncols + j;
     return *(m->values + offset);
 }
@@ -687,7 +658,7 @@ void *arena_alloc(Arena *arena, uint32_t size) {
     size = (size + 7) & ~7;
 
     if (arena->offset + size > arena->capacity) {
-        printf("Arena Out Of Memory\n");
+        rb_raise(rb_eNoMemError, "Arena Insufficient Capacity");
         return NULL;
     }
 

data/lib/ckmeans/clusterer.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
 module Ckmeans
-  class Clusterer # rubocop:disable Style/Documentation, Metrics/ClassLength
-    PI_DOUBLE = Math::PI * 2
-
+  class Clusterer # rubocop:disable Style/Documentation
     def initialize(entries, kmin, kmax = kmin, kestimate = :regular)
       @xcount = entries.size
 
@@ -26,301 +24,7 @@ module Ckmeans
           sorted_group_sizes.each_with_object([]) do |size, groups|
             groups << @xsorted_original.shift(size)
           end
-
-=begin # rubocop:disable Style/BlockComments
-          @cost   = Array.new(kmax) { Array.new(xcount) { 0.0 } }
-          @splits = Array.new(kmax) { Array.new(xcount) { 0 } }
-          @xsum   = Array.new(xcount)
-          @xsumsq = Array.new(xcount)
-
-          shift     = xsorted[xcount / 2]
-          xsum[0]   = xsorted[0].to_f - shift
-          xsumsq[0] = xsum[0]**2
-
-          1.upto(xcount - 1) do |i|
-            xf = xsorted[i].to_f
-            xsum[i]      = xsum[i - 1] + xf - shift
-            xsumsq[i]    = xsumsq[i - 1] + ((xf - shift) * (xf - shift))
-            cost[0][i]   = dissim(0, i)
-            splits[0][i] = 0
-          end
-
-          kmax_idx = kmax - 1
-          1.upto(kmax_idx) do |q|
-            imin = q < kmax_idx ? [1, q].max : xcount - 1
-            fill_row(q, imin, xcount - 1)
-          end
-
-          kopt = koptimal
-
-          puts "RB COST\n", cost.map(&:inspect)
-          puts "RB SPLITS\n", splits.map(&:inspect)
-          puts "RB K OPTIMAL: #{kopt}"
-
-          backtrack(kopt).each_with_object(Array.new(kopt)) do |(q, left, right), res|
-            res[q] = xsorted[left..right]
-          end
-=end
-        end
-    end
-
-    private
-
-    attr_reader :cost, :splits, :xsum, :xsumsq, :xcount, :xsorted, :kmin, :kmax
-
-    def koptimal # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-      kopt       = kmin
-      n          = xcount
-      max_bic    = 0.0
-      adjustment = kestimate == :sensitive ? 0.0 : 1.0 # Deviation from BIC formula to favor smaller clusters
-
-      kmin.upto(kmax) do |k|
-        sizes = backtrack(k).each_with_object(Array.new(k)) { |(q, left, right), sz| sz[q] = right - left + 1 }
-
-        index_left    = 0
-        index_right   = nil
-        loglikelihood = 0.0
-        bin_left      = nil
-        bin_right     = nil
-
-        k.times do |kb|
-          num_points_in_bin = sizes[kb]
-          index_right = index_left + num_points_in_bin - 1
-
-          if xsorted[index_left] < xsorted[index_right]
-            bin_left  = xsorted[index_left]
-            bin_right = xsorted[index_right]
-          elsif xsorted[index_left] == xsorted[index_right]
-            bin_left  = index_left == 0 ? xsorted[0] : (xsorted[index_left - 1] + xsorted[index_left]) / 2.0
-            bin_right = index_right < n - 1 ? (xsorted[index_right] + xsorted[index_right + 1]) / 2.0 : xsorted[n - 1]
-          else
-            raise "ERROR: binLeft > binRight"
-          end
-
-          bin_width = bin_right.to_f - bin_left
-
-          mean, variance = shifted_data_variance(index_left, index_right)
-
-          if variance > 0
-            (index_left..index_right).each do |i|
-              loglikelihood += -(xsorted[i] - mean) * (xsorted[i] - mean) / (2.0 * variance)
-            end
-            loglikelihood +=
-              num_points_in_bin *
-              ((Math.log(num_points_in_bin / n.to_f) * adjustment) - (0.5 * Math.log(PI_DOUBLE * variance)))
-          else
-            loglikelihood += num_points_in_bin * Math.log(1.0 / bin_width / n)
-          end
-
-          index_left = index_right + 1
-        end
-
-        bic = (2.0 * loglikelihood) - (((3 * k) - 1) * Math.log(n.to_f))
-
-        if k == kmin
-          max_bic = bic
-          kopt    = kmin
-        elsif bic > max_bic
-          max_bic = bic
-          kopt    = k
-        end
-      end
-
-      kopt
-    end
-
-    def shifted_data_variance(ileft, iright)
-      sum      = 0.0
-      sumsq    = 0.0
-      mean     = 0.0
-      variance = 0.0
-      n        = iright - ileft + 1
-
-      if iright >= ileft
-        median = xsorted[(ileft + iright) / 2].to_f
-
-        ileft.upto(iright) do |i|
-          sumi   = xsorted[i] - median
-          sum   += sumi
-          sumsq += sumi**2
-        end
-
-        mean     = (sum / n) + median
-        variance = (sumsq - (sum * sum / n)) / (n - 1) if n > 1
-      end
-
-      [mean, variance]
-    end
-
-    def backtrack(k)
-      return to_enum(__method__, k) unless block_given?
-
-      right = xcount - 1
-      left  = nil
-
-      (k - 1).downto(0) do |q|
-        left = splits[q][right]
-
-        yield q, left, right
-
-        right = left - 1 if q > 0
-      end
-    end
-
-    def dissim(j, i)
-      return 0.0 if j >= i
-
-      sji =
-        if j > 0
-          segment_sum = xsum[i] - xsum[j - 1]
-          segment_size = i - j + 1
-          xsumsq[i] - xsumsq[j - 1] - (segment_sum * segment_sum / segment_size)
-        else
-          xsumsq[i] - (xsum[i] * xsum[i] / (i + 1))
-        end
-
-      [0, sji].max
-    end
-
-    def fill_row(q, imin, imax)
-      size = imax - q + 1
-
-      js = Array.new(size) { |i| q + i }
-      smawk(imin, imax, 1, q, js)
-    end
-
-    def smawk(imin, imax, istep, q, js)
-      if (imax - imin) <= (0 * istep)
-        find_min_from_candidates(q, imin, imax, istep, js)
-      else
-        js_odd = prune_candidates(imin, imax, istep, q, js)
-        # puts "Pruned: #{js_odd.inspect}"
-        istepx2 = istep * 2
-        imin_odd = imin + istep
-        imax_odd = imin_odd + ((imax - imin_odd) / istepx2 * istepx2)
-        smawk(imin_odd, imax_odd, istepx2, q, js_odd)
-        fill_even_positions(imin, imax, istep, q, js)
-      end
-    end
-
-    def find_min_from_candidates(q, imin, imax, istep, js)
-      optimal_split_index_prev = 0
-
-      (imin..imax).step(istep) do |i|
-        optimal_split_index = optimal_split_index_prev
-        optimal_split       = js[optimal_split_index]
-        cost[q][i]          = cost[q - 1][optimal_split - 1] + dissim(optimal_split, i)
-        splits[q][i]        = optimal_split
-
-        ((optimal_split_index + 1)...js.size).each do |split_index|
-          jabs = js[split_index]
-
-          next if jabs < splits[q - 1][i]
-          break if jabs > i
-
-          sj = cost[q - 1][jabs - 1] + dissim(jabs, i)
-
-          next unless sj <= cost[q][i]
-
-          cost[q][i]               = sj
-          splits[q][i]             = js[split_index]
-          optimal_split_index_prev = split_index
-        end
-      end
-    end
-
-    def prune_candidates(imin, imax, istep, q, js)
-      n = ((imax - imin) / istep) + 1
-      m = js.size
-
-      return js if n >= m
-
-      pruned = js.dup
-      left = -1
-      right = 0
-
-      while m > n
-        p     = left + 1
-        i     = imin + (p * istep)
-        j     = pruned[right]
-        jnext = pruned[right + 1]
-        sl    = cost[q - 1][j - 1] + dissim(j, i)
-        snext = cost[q - 1][jnext - 1] + dissim(jnext, i)
-
-        if (sl < snext) && (p < n - 1)
-          left += 1
-          pruned[left] = j
-          right += 1
-        elsif (sl < snext) && (p == n - 1)
-          right += 1
-          pruned[right] = j
-          m -= 1
-        else
-          if p > 0
-            pruned[right] = pruned[left]
-            left -= 1
-          else
-            right += 1
-          end
-
-          m -= 1
-        end
-      end
-
-      ((left + 1)...m).each do |r|
-        pruned[r] = pruned[right]
-        right += 1
-      end
-
-      pruned.slice!(m..-1) if pruned.size > m
-      pruned
-    end
-
-    def fill_even_positions(imin, imax, istep, q, js)
-      n = js.size
-      istepx2 = istep * 2
-      jl = js[0]
-
-      i = imin
-      r = 0
-      while i <= imax
-        r += 1 while js[r] < jl
-
-        cost[q][i]   = cost[q - 1][js[r] - 1] + dissim(js[r], i)
-        splits[q][i] = js[r]
-        jh           = (i + istep) <= imax ? splits[q][i + istep] : js[n - 1]
-        jmax         = [jh, i].min
-        sjimin       = dissim(jmax, i)
-
-        r += 1
-        while r < n && js[r] <= jmax
-          jabs = js[r]
-
-          break if jabs > i
-
-          if jabs < splits[q - 1][i]
-            r += 1
-            next
-          end
-
-          cost_base = cost[q - 1][jabs - 1]
-          sj        = cost_base + dissim(jabs, i)
-
-          if sj <= cost[q][i]
-            cost[q][i]   = sj
-            splits[q][i] = jabs
-          elsif cost_base + sjimin > cost[q][i]
-            break
-          end
-
-          r += 1
         end
-
-        r -= 1
-        jl = jh
-
-        i += istepx2
-      end
     end
   end
 end

data/lib/ckmeans/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ckmeans
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Vlad Lebedev
 bindir: exe
 cert_chain: []
-date: 2025-04-22 00:00:00.000000000 Z
+date: 2025-04-24 00:00:00.000000000 Z
 dependencies: []
 description: Repeatable clustering of unidimensional data
 email: