umappp 0.2.1 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d88fcf9fcf8f61232a094afbf62a7aa421c564e644a854bd2efc1ba94dd1ab02
-  data.tar.gz: a92531b8da81479a4844ec5f5073423eefdf3fb9d32bed6f7cbe867771116087
+  metadata.gz: f50fd5a0af819b29f30afbf2cad8e059c679b9691b2c42a106724d7c9cb313e3
+  data.tar.gz: d4f583765cc15aec1f4102d35699208cac47df086cea14fd485eb99c15b8a027
 SHA512:
-  metadata.gz: c56ce6be1fe5d9f296b512121be5e94cd844d2ea76ec75ad8e3224ace4023a45146da5cfe4fa779d557c99afbce85a22b951cd2b21a8b1f4f151c5911b13d12a
-  data.tar.gz: 21be7903f3aa0f03c0a60bf011415f115501e6741a94791465a6e25789ed2c411aed87042b11eeb15aa8ac43d39dff9000a30a7c79cdd0de1b310bd7f5b30044
+  metadata.gz: 9a505cbe40f4b059dc2af714759fe1cbcda70cd132fe08fe1e463a20e93c3fa3b8981152116b94e2f5e3ff1aa344959d0f815368c1838cef17cdcdfb6288dce6
+  data.tar.gz: 7798c54f1a7bd98fb3decc32ef779e945b41d3332bd2d3b5a0c58570c084840a2da5c0af57b185d4c57b93d3b49506cb65ac86d5ccb48ba9570ba013b4de71ef

data/README.md

@@ -27,16 +27,22 @@ gem install umappp
 This Gem provides the module `Umappp` and its singular method `Umappp.run()`. The first argument of `Umappp.run()` is a two-dimensional Ruby array or a two-dimensional Numo array. [Numo](https://github.com/ruby-numo/numo-narray) is a library for performing N-dimensional array computing like NumPy. The argument is converted to `Numo::SFloat`. SFloat is a single precision floating point number type of Numo::NArray.
 
 ```ruby
-# The embedding is two-dimensional Ruby array or Numo array
-# Returns Numo::SFloat
-r = Umappp.run(embedding)
+# Original high-dimensional data as two-dimensional Ruby array or Numo array
+data = Numo::SFloat.new(10, 784).rand # e.g. 10 images with 784 features
+
+# Returns low-dimensional embedding as Numo::SFloat
+embedding = Umappp.run(data)
 
 # Run with parameters
-r = Umappp.run(pixels, num_threads: 8, a: 1.8956, b: 0.8006)
+embedding = Umappp.run(data, num_threads: 8, a: 1.8956, b: 0.8006)
 ```
 
 Available parameters and their default values
 
+(The defaults are obtained from the underlying C++ Umappp
+library via `Umappp.default_parameters` and may change when
+the bundled Umappp version is updated.)
+
 | parameters           | default value                      |
 | -------------------- | ---------------------------------- |
 | method               | :annoy (another option is :vptree) |
@@ -57,11 +63,15 @@ Available parameters and their default values
 | seed                 | 1234567890                         |
 | num_threads          | 1 (OpenMP required)                |
 
+For the `initialize` parameter, this gem currently accepts the
+symbols `:spectral`, `:spectral_only`, `:random` and `:none`,
+which are mapped to `Umappp::InitMethod` values internally.
+
 ## Development
 
 ```
 git clone https://github.com/kojix2/ruby-umappp
-cd umap
+cd ruby-umappp
 bundle exec rake compile
 bundle exec rake test
 ```

data/ext/umappp/numo.hpp

@@ -1,5 +1,5 @@
 /*!
- * Numo.hpp v0.2.0
+ * Numo.hpp v0.2.1
  * https://github.com/ankane/numo.hpp
  * BSD-2-Clause License
  */
@@ -449,18 +449,19 @@ private:
 namespace Rice::detail {
 
 template<>
-struct Type<numo::NArray>
-{
+struct Type<numo::NArray> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::NArray>
-{
+class From_Ruby<numo::NArray> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(value))
-    {
+    switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::NArray>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
@@ -473,30 +474,40 @@ public:
   numo::NArray convert(VALUE x) {
     return numo::NArray(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::NArray>
-{
+class To_Ruby<numo::NArray> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::NArray& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-struct Type<numo::SFloat>
-{
+struct Type<numo::SFloat> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::SFloat>
-{
+class From_Ruby<numo::SFloat> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(value))
-    {
+    switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::SFloat>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
@@ -509,30 +520,40 @@ public:
   numo::SFloat convert(VALUE x) {
     return numo::SFloat(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::SFloat>
-{
+class To_Ruby<numo::SFloat> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::SFloat& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-struct Type<numo::DFloat>
-{
+struct Type<numo::DFloat> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::DFloat>
-{
+class From_Ruby<numo::DFloat> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(value))
-    {
+    switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::DFloat>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
@@ -545,30 +566,40 @@ public:
   numo::DFloat convert(VALUE x) {
     return numo::DFloat(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::DFloat>
-{
+class To_Ruby<numo::DFloat> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::DFloat& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-struct Type<numo::Int8>
-{
+struct Type<numo::Int8> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::Int8>
-{
+class From_Ruby<numo::Int8> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(value))
-    {
+    switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::Int8>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
@@ -581,30 +612,40 @@ public:
   numo::Int8 convert(VALUE x) {
     return numo::Int8(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::Int8>
-{
+class To_Ruby<numo::Int8> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::Int8& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-struct Type<numo::Int16>
-{
+struct Type<numo::Int16> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::Int16>
-{
+class From_Ruby<numo::Int16> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(value))
-    {
+    switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::Int16>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
@@ -617,30 +658,40 @@ public:
   numo::Int16 convert(VALUE x) {
     return numo::Int16(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::Int16>
-{
+class To_Ruby<numo::Int16> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::Int16& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-struct Type<numo::Int32>
-{
+struct Type<numo::Int32> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::Int32>
-{
+class From_Ruby<numo::Int32> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(value))
-    {
+    switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::Int32>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
@@ -653,30 +704,40 @@ public:
   numo::Int32 convert(VALUE x) {
     return numo::Int32(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::Int32>
-{
+class To_Ruby<numo::Int32> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::Int32& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-struct Type<numo::Int64>
-{
+struct Type<numo::Int64> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::Int64>
-{
+class From_Ruby<numo::Int64> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(value))
-    {
+    switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::Int64>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
@@ -689,30 +750,40 @@ public:
   numo::Int64 convert(VALUE x) {
     return numo::Int64(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::Int64>
-{
+class To_Ruby<numo::Int64> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::Int64& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-struct Type<numo::UInt8>
-{
+struct Type<numo::UInt8> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::UInt8>
-{
+class From_Ruby<numo::UInt8> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(value))
-    {
+    switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::UInt8>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
@@ -725,30 +796,40 @@ public:
   numo::UInt8 convert(VALUE x) {
     return numo::UInt8(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::UInt8>
-{
+class To_Ruby<numo::UInt8> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::UInt8& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-struct Type<numo::UInt16>
-{
+struct Type<numo::UInt16> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::UInt16>
-{
+class From_Ruby<numo::UInt16> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(value))
-    {
+    switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::UInt16>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
@@ -761,30 +842,40 @@ public:
   numo::UInt16 convert(VALUE x) {
     return numo::UInt16(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::UInt16>
-{
+class To_Ruby<numo::UInt16> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::UInt16& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-struct Type<numo::UInt32>
-{
+struct Type<numo::UInt32> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::UInt32>
-{
+class From_Ruby<numo::UInt32> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(value))
-    {
+    switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::UInt32>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
@@ -797,30 +888,40 @@ public:
   numo::UInt32 convert(VALUE x) {
     return numo::UInt32(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::UInt32>
-{
+class To_Ruby<numo::UInt32> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::UInt32& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-struct Type<numo::UInt64>
-{
+struct Type<numo::UInt64> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::UInt64>
-{
+class From_Ruby<numo::UInt64> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(value))
-    {
+    switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::UInt64>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
@@ -833,30 +934,40 @@ public:
   numo::UInt64 convert(VALUE x) {
     return numo::UInt64(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::UInt64>
-{
+class To_Ruby<numo::UInt64> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::UInt64& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-struct Type<numo::SComplex>
-{
+struct Type<numo::SComplex> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::SComplex>
-{
+class From_Ruby<numo::SComplex> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(value))
-    {
+    switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::SComplex>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
@@ -869,30 +980,40 @@ public:
   numo::SComplex convert(VALUE x) {
     return numo::SComplex(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::SComplex>
-{
+class To_Ruby<numo::SComplex> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::SComplex& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-struct Type<numo::DComplex>
-{
+struct Type<numo::DComplex> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::DComplex>
-{
+class From_Ruby<numo::DComplex> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(value))
-    {
+    switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::DComplex>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
@@ -905,30 +1026,40 @@ public:
   numo::DComplex convert(VALUE x) {
     return numo::DComplex(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::DComplex>
-{
+class To_Ruby<numo::DComplex> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::DComplex& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-struct Type<numo::Bit>
-{
+struct Type<numo::Bit> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::Bit>
-{
+class From_Ruby<numo::Bit> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(value))
-    {
+    switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::Bit>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
@@ -941,30 +1072,40 @@ public:
   numo::Bit convert(VALUE x) {
     return numo::Bit(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::Bit>
-{
+class To_Ruby<numo::Bit> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::Bit& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-struct Type<numo::RObject>
-{
+struct Type<numo::RObject> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::RObject>
-{
+class From_Ruby<numo::RObject> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(value))
-    {
+    switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::RObject>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
@@ -977,15 +1118,24 @@ public:
   numo::RObject convert(VALUE x) {
     return numo::RObject(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::RObject>
-{
+class To_Ruby<numo::RObject> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::RObject& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 }

data/ext/umappp/umappp.cpp

@@ -1,8 +1,12 @@
-// Uniform Manifold Approximation and Projection for Ruby
-// https://github.com/kojix2/ruby-umappp
+/*
+ * Uniform Manifold Approximation and Projection for Ruby
+ * https://github.com/kojix2/ruby-umappp
+ */
 
 #include <rice/rice.hpp>
 #include <rice/stl.hpp>
+#include <exception>
+#include <string>
 #include "numo.hpp"
 #include "Umap.hpp"
 
@@ -11,8 +15,44 @@ typedef typename umappp::Umap<Float> Umap;
 
 using namespace Rice;
 
-// This function is used to view default parameters from Ruby.
+// Data structure for running UMAP calculation without GVL.
+struct UmapRunData
+{
+  Umap *umap_ptr;
+  knncolle::Base<int, Float> *knncolle_ptr;
+  int ndim;
+  std::vector<Float> *embedding;
+  std::string exception_message;
+  bool exception_thrown = false;
+};
+
+// Callback for UMAP calculation (executed without GVL).
+static void *umap_run_without_gvl(void *data)
+{
+  UmapRunData *run_data = static_cast<UmapRunData *>(data);
+  try
+  {
+    auto status = run_data->umap_ptr->initialize(
+        run_data->knncolle_ptr,
+        run_data->ndim,
+        run_data->embedding->data());
+    int epoch_limit = 0;
+    status.run(epoch_limit);
+  }
+  catch (const std::exception &e)
+  {
+    run_data->exception_message = e.what();
+    run_data->exception_thrown = true;
+  }
+  catch (...)
+  {
+    run_data->exception_message = "Unknown exception occurred in UMAP calculation.";
+    run_data->exception_thrown = true;
+  }
+  return nullptr;
+}
 
+// Returns default parameters from the Umappp C++ library.
 Hash umappp_default_parameters(Object self)
 {
   Hash d;
@@ -36,8 +76,7 @@ Hash umappp_default_parameters(Object self)
   return d;
 }
 
-// Function to perform umap.
-
+// Main function to perform UMAP.
 Object umappp_run(
     Object self,
     Hash params,
@@ -45,8 +84,6 @@ Object umappp_run(
     int ndim,
     int nn_method)
 {
-  // Parameters are taken from a Ruby Hash object.
-  // If there is key, set the value.
   if (ndim < 1)
   {
     throw std::runtime_error("ndim is less than 1");
@@ -166,16 +203,18 @@ Object umappp_run(
     umap_ptr->set_parallel_optimization(parallel_optimization);
   }
 
-  // initialize_from_matrix
-
   const float *y = data.read_ptr();
   size_t *shape = data.shape();
 
   int nd = shape[1];
   int nobs = shape[0];
-  if (nobs < 0)
+  if (nobs <= 0)
   {
-    throw std::runtime_error("nobs is negative");
+    throw std::runtime_error("number of observations must be positive");
+  }
+  if (nd <= 0)
+  {
+    throw std::runtime_error("number of dimensions must be positive");
   }
 
   std::unique_ptr<knncolle::Base<int, Float>> knncolle_ptr;
@@ -187,16 +226,31 @@ Object umappp_run(
   {
     knncolle_ptr.reset(new knncolle::KmknnEuclidean<int, Float>(nd, nobs, y));
   }
+  else
+  {
+    throw std::runtime_error("unknown nearest neighbor method");
+  }
 
   std::vector<Float> embedding(ndim * nobs);
 
-  auto status = umap_ptr->initialize(knncolle_ptr.get(), ndim, embedding.data());
+  // Run UMAP calculation without GVL.
+  UmapRunData run_data = {
+      umap_ptr.get(),
+      knncolle_ptr.get(),
+      ndim,
+      &embedding};
+
+  rb_thread_call_without_gvl(
+      umap_run_without_gvl,
+      &run_data,
+      NULL,
+      NULL);
 
-  int epoch_limit = 0;
-  // tick is not implemented yet
-  status.run(epoch_limit);
+  if (run_data.exception_thrown)
+  {
+    throw std::runtime_error(run_data.exception_message);
+  }
 
-  // it is safe to cast to unsigned int
   auto na = numo::SFloat({(unsigned int)nobs, (unsigned int)ndim});
   std::copy(embedding.begin(), embedding.end(), na.write_ptr());
 

data/lib/umappp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Umappp
-  VERSION = "0.2.1"
+  VERSION = "0.2.3"
 end

data/lib/umappp.rb

@@ -19,7 +19,7 @@ module Umappp
   # Runs the Uniform Manifold Approximation and Projection (UMAP) dimensional
   # reduction technique.
   # @param embedding [Array, Numo::SFloat]
-  # @param method [Symbol]
+  # @param method [Symbol, String]
   # @param ndim [Integer]
   # @param tick [Integer]
   # @param local_connectivity [Numeric]
@@ -30,7 +30,7 @@ module Umappp
   # @param a [Numeric]
   # @param b [Numeric]
   # @param repulsion_strength [Numeric]
-  # @param initilaize [Umappp::InitMethod]
+  # @param initialize [Symbol, Umappp::InitMethod]
   # @param num_epochs [Integer]
   # @param learning_rate [Numeric]
   # @param negative_sample_rate [Numeric]
@@ -42,14 +42,43 @@ module Umappp
 
   def self.run(embedding, method: :annoy, ndim: 2, **params)
     unless (u = (params.keys - default_parameters.keys)).empty?
-      raise ArgumentError, "[umappp.rb] unknown option : #{u.inspect}"
+      raise ArgumentError, "Unknown option(s): #{u.inspect}"
     end
 
     nnmethod = %i[annoy vptree].index(method.to_sym)
     raise ArgumentError, "method must be :annoy or :vptree" if nnmethod.nil?
 
+    # Allow initialize: to be specified as a Symbol or String and
+    # convert it to the corresponding Umappp::InitMethod enum.
+    if params.key?(:initialize)
+      init_val = params[:initialize]
+
+      if init_val.is_a?(Symbol) || init_val.is_a?(String)
+        init_sym = init_val.to_sym
+        mapping = {
+          spectral: InitMethod::SPECTRAL,
+          spectral_only: InitMethod::SPECTRAL_ONLY,
+          random: InitMethod::RANDOM,
+          none: InitMethod::NONE
+        }
+
+        mapped = mapping[init_sym]
+        unless mapped
+          raise ArgumentError,
+                "initialize must be one of :spectral, :spectral_only, :random, :none or a Umappp::InitMethod"
+        end
+
+        params[:initialize] = mapped
+      end
+      # If it's already a Umappp::InitMethod, we just pass it through.
+    end
+
     embedding2 = Numo::SFloat.cast(embedding)
-    raise ArgumentError, "embedding must be a 2D array" if embedding2.ndim <= 1
+    if embedding2.ndim != 2
+      raise ArgumentError,
+            "embedding must be a 2D array, got #{embedding2.ndim}D with shape #{embedding2.shape.inspect}"
+    end
+    raise ArgumentError, "embedding must not be empty" if embedding2.empty?
 
     umappp_run(params, embedding2, ndim, nnmethod)
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: umappp
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.3
 platform: ruby
 authors:
 - kojix2
@@ -456,7 +456,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.7.2
 specification_version: 4
 summary: Umap for Ruby
 test_files: []