clusterkit 0.2.4 → 0.2.5

data/ext/clusterkit/src/lib.rs

@@ -1,4 +1,4 @@
-use magnus::{define_module, Error};
+use magnus::{Error, Ruby};
 
 mod embedder;
 mod svd;
@@ -10,15 +10,15 @@ mod hnsw;
 mod tests;
 
 #[magnus::init]
-fn init() -> Result<(), Error> {
-    let module = define_module("ClusterKit")?;
-    
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let module = ruby.define_module("ClusterKit")?;
+
     // Initialize submodules
     embedder::init(&module)?;
     svd::init(&module)?;
     utils::init(&module)?;
     clustering::init(&module)?;
     hnsw::init(&module)?;
-    
+
     Ok(())
 }

data/ext/clusterkit/src/svd.rs

@@ -1,91 +1,89 @@
-use magnus::{function, prelude::*, Error, Value, RArray};
+use magnus::{function, prelude::*, Error, Value, RArray, Ruby};
 use annembed::tools::svdapprox::{SvdApprox, RangeApproxMode, RangeRank, MatRepr};
 use crate::utils::ruby_array_to_ndarray2;
 
 pub fn init(parent: &magnus::RModule) -> Result<(), Error> {
     let svd_module = parent.define_module("SVD")?;
-    
+
     svd_module.define_singleton_method(
         "randomized_svd_rust",
         function!(randomized_svd, 3),
     )?;
-    
+
     Ok(())
 }
 
 fn randomized_svd(matrix: Value, k: usize, n_iter: usize) -> Result<RArray, Error> {
+    let ruby = Ruby::get().unwrap();
+
     // Convert Ruby array to ndarray using shared helper
     let matrix_data = ruby_array_to_ndarray2(matrix)?;
     let (n_rows, n_cols) = matrix_data.dim();
-    
+
     if k > n_rows.min(n_cols) {
         return Err(Error::new(
-            magnus::exception::arg_error(),
+            ruby.exception_arg_error(),
             format!("k ({}) cannot be larger than min(rows, cols) = {}", k, n_rows.min(n_cols)),
         ));
     }
-    
+
     // Create MatRepr for the full matrix
     let mat_repr = MatRepr::from_array2(matrix_data.clone());
-    
+
     // Create SvdApprox instance
     let mut svd_approx = SvdApprox::new(&mat_repr);
-    
+
     // Set up parameters for randomized SVD
-    // Use RANK mode to specify the desired rank
     let params = RangeApproxMode::RANK(RangeRank::new(k, n_iter));
-    
+
     // Perform SVD
     let svd_result = svd_approx.direct_svd(params)
-        .map_err(|e| Error::new(magnus::exception::runtime_error(), e))?;
-    
-    // Extract U, S, V from the result - they are optional fields
+        .map_err(|e| Error::new(ruby.exception_runtime_error(), e))?;
+
+    // Extract U, S, V from the result
     let u_matrix = svd_result.u.ok_or_else(|| {
-        Error::new(magnus::exception::runtime_error(), "No U matrix in SVD result")
+        Error::new(ruby.exception_runtime_error(), "No U matrix in SVD result")
     })?;
-    
+
     let s_values = svd_result.s.ok_or_else(|| {
-        Error::new(magnus::exception::runtime_error(), "No S values in SVD result")
+        Error::new(ruby.exception_runtime_error(), "No S values in SVD result")
     })?;
-    
+
     let vt_matrix = svd_result.vt.ok_or_else(|| {
-        Error::new(magnus::exception::runtime_error(), "No V^T matrix in SVD result")
+        Error::new(ruby.exception_runtime_error(), "No V^T matrix in SVD result")
     })?;
-    
+
     // Convert results to Ruby arrays
-    // U matrix - convert ndarray to Ruby nested array
-    let u_ruby = RArray::new();
+    let u_ruby = ruby.ary_new();
     let u_shape = u_matrix.shape();
     for i in 0..u_shape[0] {
-        let row = RArray::new();
+        let row = ruby.ary_new();
         for j in 0..u_shape[1] {
             row.push(u_matrix[[i, j]])?;
         }
         u_ruby.push(row)?;
     }
-    
-    // S values - convert to Ruby array
-    let s_ruby = RArray::new();
+
+    let s_ruby = ruby.ary_new();
     for val in s_values.iter() {
         s_ruby.push(*val)?;
     }
-    
-    // V matrix (note: we have V^T, so we need to transpose)
-    let v_ruby = RArray::new();
+
+    let v_ruby = ruby.ary_new();
     let vt_shape = vt_matrix.shape();
     for i in 0..vt_shape[0] {
-        let row = RArray::new();
+        let row = ruby.ary_new();
         for j in 0..vt_shape[1] {
             row.push(vt_matrix[[i, j]])?;
         }
         v_ruby.push(row)?;
     }
-    
+
     // Return [U, S, V^T] as a Ruby array
-    let result = RArray::new();
+    let result = ruby.ary_new();
     result.push(u_ruby)?;
     result.push(s_ruby)?;
     result.push(v_ruby)?;
-    
+
     Ok(result)
-}
+}

data/ext/clusterkit/src/utils.rs

@@ -1,34 +1,34 @@
-use magnus::{function, prelude::*, Error, Value, RArray, TryConvert, Float, Integer};
+use magnus::{function, prelude::*, Error, Value, RArray, TryConvert, Float, Integer, Ruby};
 use ndarray::Array2;
 
 pub fn init(parent: &magnus::RModule) -> Result<(), Error> {
     let utils_module = parent.define_module("Utils")?;
-    
+
     utils_module.define_singleton_method(
         "estimate_intrinsic_dimension_rust",
         function!(estimate_intrinsic_dimension, 2),
     )?;
-    
+
     utils_module.define_singleton_method(
         "estimate_hubness_rust",
         function!(estimate_hubness, 1),
     )?;
-    
+
     Ok(())
 }
 
 fn estimate_intrinsic_dimension(_data: Value, _k_neighbors: usize) -> Result<f64, Error> {
-    // TODO: Implement using annembed
+    let ruby = Ruby::get().unwrap();
     Err(Error::new(
-        magnus::exception::not_imp_error(),
+        ruby.exception_not_imp_error(),
         "Dimension estimation not implemented yet",
     ))
 }
 
 fn estimate_hubness(_data: Value) -> Result<Value, Error> {
-    // TODO: Implement using annembed
+    let ruby = Ruby::get().unwrap();
     Err(Error::new(
-        magnus::exception::not_imp_error(),
+        ruby.exception_not_imp_error(),
         "Hubness estimation not implemented yet",
     ))
 }
@@ -36,12 +36,13 @@ fn estimate_hubness(_data: Value) -> Result<Value, Error> {
 /// Convert Ruby 2D array to ndarray Array2<f64>
 /// Handles validation and provides consistent error messages
 pub fn ruby_array_to_ndarray2(data: Value) -> Result<Array2<f64>, Error> {
+    let ruby = Ruby::get().unwrap();
     let rarray: RArray = TryConvert::try_convert(data)?;
     let n_samples = rarray.len();
 
     if n_samples == 0 {
         return Err(Error::new(
-            magnus::exception::arg_error(),
+            ruby.exception_arg_error(),
             "Data cannot be empty",
         ));
     }
@@ -52,7 +53,7 @@ pub fn ruby_array_to_ndarray2(data: Value) -> Result<Array2<f64>, Error> {
 
     if n_features == 0 {
         return Err(Error::new(
-            magnus::exception::arg_error(),
+            ruby.exception_arg_error(),
             "Data rows cannot be empty",
         ));
     }
@@ -61,11 +62,11 @@ pub fn ruby_array_to_ndarray2(data: Value) -> Result<Array2<f64>, Error> {
     let mut data_array = Array2::<f64>::zeros((n_samples, n_features));
     for i in 0..n_samples {
         let row: RArray = rarray.entry(i as isize)?;
-        
+
         // Validate row length consistency
         if row.len() != n_features {
             return Err(Error::new(
-                magnus::exception::arg_error(),
+                ruby.exception_arg_error(),
                 format!("Row {} has {} elements, expected {}", i, row.len(), n_features),
             ));
         }
@@ -80,14 +81,15 @@ pub fn ruby_array_to_ndarray2(data: Value) -> Result<Array2<f64>, Error> {
 }
 
 /// Convert Ruby 2D array to Vec<Vec<f64>>
-/// Handles validation and provides consistent error messages  
+/// Handles validation and provides consistent error messages
 pub fn ruby_array_to_vec_vec_f64(data: Value) -> Result<Vec<Vec<f64>>, Error> {
+    let ruby = Ruby::get().unwrap();
     let rarray: RArray = TryConvert::try_convert(data)?;
     let n_samples = rarray.len();
 
     if n_samples == 0 {
         return Err(Error::new(
-            magnus::exception::arg_error(),
+            ruby.exception_arg_error(),
             "Data cannot be empty",
         ));
     }
@@ -98,13 +100,13 @@ pub fn ruby_array_to_vec_vec_f64(data: Value) -> Result<Vec<Vec<f64>>, Error> {
     for i in 0..n_samples {
         let row: RArray = rarray.entry(i as isize)?;
         let n_features = row.len();
-        
+
         // Check row length consistency
         match expected_features {
             Some(expected) => {
                 if n_features != expected {
                     return Err(Error::new(
-                        magnus::exception::arg_error(),
+                        ruby.exception_arg_error(),
                         format!("Row {} has {} elements, expected {}", i, n_features, expected),
                     ));
                 }
@@ -126,12 +128,13 @@ pub fn ruby_array_to_vec_vec_f64(data: Value) -> Result<Vec<Vec<f64>>, Error> {
 /// Convert Ruby 2D array to Vec<Vec<f32>>
 /// For algorithms that require f32 precision (like UMAP)
 pub fn ruby_array_to_vec_vec_f32(data: Value) -> Result<Vec<Vec<f32>>, Error> {
+    let ruby = Ruby::get().unwrap();
     let rarray: RArray = TryConvert::try_convert(data)?;
     let array_len = rarray.len();
 
     if array_len == 0 {
         return Err(Error::new(
-            magnus::exception::arg_error(),
+            ruby.exception_arg_error(),
             "Input data cannot be empty",
         ));
     }
@@ -142,7 +145,7 @@ pub fn ruby_array_to_vec_vec_f32(data: Value) -> Result<Vec<Vec<f32>>, Error> {
         let row = rarray.entry::<Value>(i as isize)?;
         let row_array = RArray::try_convert(row).map_err(|_| {
             Error::new(
-                magnus::exception::type_error(),
+                ruby.exception_type_error(),
                 "Expected array of arrays (2D array)",
             )
         })?;
@@ -158,7 +161,7 @@ pub fn ruby_array_to_vec_vec_f32(data: Value) -> Result<Vec<Vec<f32>>, Error> {
                 i.to_i64()? as f32
             } else {
                 return Err(Error::new(
-                    magnus::exception::type_error(),
+                    ruby.exception_type_error(),
                     "All values must be numeric",
                 ));
             };
@@ -168,7 +171,7 @@ pub fn ruby_array_to_vec_vec_f32(data: Value) -> Result<Vec<Vec<f32>>, Error> {
         // Validate row length consistency
         if !rust_data.is_empty() && rust_row.len() != rust_data[0].len() {
             return Err(Error::new(
-                magnus::exception::arg_error(),
+                ruby.exception_arg_error(),
                 "All rows must have the same length",
             ));
         }
@@ -177,4 +180,4 @@ pub fn ruby_array_to_vec_vec_f32(data: Value) -> Result<Vec<Vec<f32>>, Error> {
     }
 
     Ok(rust_data)
-}
+}

data/lib/clusterkit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ClusterKit
-  VERSION = "0.2.4"
+  VERSION = "0.2.5"
 end

data/lib/clusterkit.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "clusterkit/version"
-require_relative "clusterkit/clusterkit"
+require "clusterkit/clusterkit"
 require_relative "clusterkit/configuration"
 
 # Main module for ClusterKit gem

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: clusterkit
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors:
 - Chris Petersen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-28 00:00:00.000000000 Z
+date: 2026-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: benchmark
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: csv
   requirement: !ruby/object:Gem::Requirement
@@ -130,7 +144,6 @@ files:
 - PYTHON_COMPARISON.md
 - README.md
 - Rakefile
-- clusterkit.gemspec
 - docs/KNOWN_ISSUES.md
 - docs/RUST_ERROR_HANDLING.md
 - docs/TEST_FIXTURES.md
@@ -194,7 +207,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: High-performance clustering and dimensionality reduction for Ruby

data/clusterkit.gemspec

@@ -1,45 +0,0 @@
-require_relative "lib/clusterkit/version"
-
-Gem::Specification.new do |spec|
-  spec.name = "clusterkit"
-  spec.version = ClusterKit::VERSION
-  spec.authors = ["Chris Petersen"]
-  spec.email = ["chris@petersen.io"]
-
-  spec.summary = "High-performance clustering and dimensionality reduction for Ruby"
-  spec.description = "A comprehensive clustering toolkit for Ruby, providing UMAP, PCA, K-means, HDBSCAN and more. Built on top of annembed and hdbscan Rust crates for blazing-fast performance."
-  spec.homepage = "https://github.com/scientist-labs/clusterkit"
-  spec.license = "MIT"
-  spec.required_ruby_version = ">= 2.7.0"
-
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = spec.homepage
-  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
-
-  # Specify which files should be added to the gem when it is released.
-  spec.files = Dir.chdir(__dir__) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
-    end + Dir["ext/**/*.rs", "ext/**/*.toml"]
-  end
-  spec.bindir = "exe"
-  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-  spec.extensions = ["ext/clusterkit/extconf.rb"]
-
-  # Runtime dependencies
-  # Numo is optional but recommended for better performance
-  # spec.add_dependency "numo-narray", "~> 0.9"
-  spec.add_dependency "rb_sys", "~> 0.9"
-
-  # Development dependencies
-  spec.add_development_dependency "csv"
-  spec.add_development_dependency "rake", "~> 13.0"
-  spec.add_development_dependency "rake-compiler", "~> 1.2"
-  spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "simplecov", "~> 0.22"
-  spec.add_development_dependency "yard", "~> 0.9"
-
-  # For more information and examples about making a new gem, check out our
-  # guide at: https://bundler.io/guides/creating_gem.html
-end