torch-rb 0.6.0 → 0.8.2

data/ext/torch/backends.cpp

@@ -0,0 +1,17 @@
+#include <torch/torch.h>
+
+#include <rice/rice.hpp>
+
+#include "utils.h"
+
+void init_backends(Rice::Module& m) {
+  auto rb_mBackends = Rice::define_module_under(m, "Backends");
+
+   Rice::define_module_under(rb_mBackends, "OpenMP")
+    .add_handler<torch::Error>(handle_error)
+    .define_singleton_function("available?", &torch::hasOpenMP);
+
+   Rice::define_module_under(rb_mBackends, "MKL")
+    .add_handler<torch::Error>(handle_error)
+    .define_singleton_function("available?", &torch::hasMKL);
+}

data/ext/torch/cuda.cpp

@@ -1,14 +1,14 @@
 #include <torch/torch.h>
 
-#include <rice/Module.hpp>
+#include <rice/rice.hpp>
 
 #include "utils.h"
 
 void init_cuda(Rice::Module& m) {
   Rice::define_module_under(m, "CUDA")
     .add_handler<torch::Error>(handle_error)
-    .define_singleton_method("available?", &torch::cuda::is_available)
-    .define_singleton_method("device_count", &torch::cuda::device_count)
-    .define_singleton_method("manual_seed", &torch::cuda::manual_seed)
-    .define_singleton_method("manual_seed_all", &torch::cuda::manual_seed_all);
+    .define_singleton_function("available?", &torch::cuda::is_available)
+    .define_singleton_function("device_count", &torch::cuda::device_count)
+    .define_singleton_function("manual_seed", &torch::cuda::manual_seed)
+    .define_singleton_function("manual_seed_all", &torch::cuda::manual_seed_all);
 }

data/ext/torch/device.cpp

@@ -1,19 +1,26 @@
 #include <torch/torch.h>
 
-#include <rice/Constructor.hpp>
-#include <rice/Module.hpp>
+#include <rice/rice.hpp>
 
 #include "utils.h"
 
 void init_device(Rice::Module& m) {
   Rice::define_class_under<torch::Device>(m, "Device")
     .add_handler<torch::Error>(handle_error)
-    .define_constructor(Rice::Constructor<torch::Device, std::string>())
-    .define_method("index", &torch::Device::index)
-    .define_method("index?", &torch::Device::has_index)
+    .define_constructor(Rice::Constructor<torch::Device, const std::string&>())
+    .define_method(
+      "index",
+      [](torch::Device& self) {
+        return self.index();
+      })
+    .define_method(
+      "index?",
+      [](torch::Device& self) {
+        return self.has_index();
+      })
     .define_method(
       "type",
-      *[](torch::Device& self) {
+      [](torch::Device& self) {
         std::stringstream s;
         s << self.type();
         return s.str();

data/ext/torch/ext.cpp

@@ -1,12 +1,18 @@
-#include <rice/Module.hpp>
+#include <torch/torch.h>
 
+#include <rice/rice.hpp>
+
+void init_fft(Rice::Module& m);
+void init_linalg(Rice::Module& m);
 void init_nn(Rice::Module& m);
-void init_tensor(Rice::Module& m);
+void init_special(Rice::Module& m);
+void init_tensor(Rice::Module& m, Rice::Class& c, Rice::Class& rb_cTensorOptions);
 void init_torch(Rice::Module& m);
 
+void init_backends(Rice::Module& m);
 void init_cuda(Rice::Module& m);
 void init_device(Rice::Module& m);
-void init_ivalue(Rice::Module& m);
+void init_ivalue(Rice::Module& m, Rice::Class& rb_cIValue);
 void init_random(Rice::Module& m);
 
 extern "C"
@@ -14,13 +20,24 @@ void Init_ext()
 {
   auto m = Rice::define_module("Torch");
 
+  // need to define certain classes up front to keep Rice happy
+  auto rb_cIValue = Rice::define_class_under<torch::IValue>(m, "IValue")
+    .define_constructor(Rice::Constructor<torch::IValue>());
+  auto rb_cTensor = Rice::define_class_under<torch::Tensor>(m, "Tensor");
+  auto rb_cTensorOptions = Rice::define_class_under<torch::TensorOptions>(m, "TensorOptions")
+    .define_constructor(Rice::Constructor<torch::TensorOptions>());
+
   // keep this order
   init_torch(m);
-  init_tensor(m);
+  init_tensor(m, rb_cTensor, rb_cTensorOptions);
   init_nn(m);
+  init_fft(m);
+  init_linalg(m);
+  init_special(m);
 
+  init_backends(m);
   init_cuda(m);
   init_device(m);
-  init_ivalue(m);
+  init_ivalue(m, rb_cIValue);
   init_random(m);
 }

data/ext/torch/extconf.rb

@@ -1,8 +1,6 @@
 require "mkmf-rice"
 
-abort "Missing stdc++" unless have_library("stdc++")
-
-$CXXFLAGS += " -std=c++14"
+$CXXFLAGS += " -std=c++17 $(optflags)"
 
 # change to 0 for Linux pre-cxx11 ABI version
 $CXXFLAGS += " -D_GLIBCXX_USE_CXX11_ABI=1"

data/ext/torch/fft.cpp

@@ -0,0 +1,13 @@
+#include <torch/torch.h>
+
+#include <rice/rice.hpp>
+
+#include "fft_functions.h"
+#include "templates.h"
+#include "utils.h"
+
+void init_fft(Rice::Module& m) {
+  auto rb_mFFT = Rice::define_module_under(m, "FFT");
+  rb_mFFT.add_handler<torch::Error>(handle_error);
+  add_fft_functions(rb_mFFT);
+}

data/ext/torch/fft_functions.h

@@ -0,0 +1,6 @@
+// generated by rake generate:functions
+// do not edit by hand
+
+#pragma once
+
+void add_fft_functions(Rice::Module& m);

data/ext/torch/ivalue.cpp

@@ -1,18 +1,13 @@
 #include <torch/torch.h>
 
-#include <rice/Array.hpp>
-#include <rice/Constructor.hpp>
-#include <rice/Hash.hpp>
-#include <rice/Module.hpp>
-#include <rice/String.hpp>
+#include <rice/rice.hpp>
 
 #include "utils.h"
 
-void init_ivalue(Rice::Module& m) {
+void init_ivalue(Rice::Module& m, Rice::Class& rb_cIValue) {
   // https://pytorch.org/cppdocs/api/structc10_1_1_i_value.html
-  Rice::define_class_under<torch::IValue>(m, "IValue")
+  rb_cIValue
     .add_handler<torch::Error>(handle_error)
-    .define_constructor(Rice::Constructor<torch::IValue>())
     .define_method("bool?", &torch::IValue::isBool)
     .define_method("bool_list?", &torch::IValue::isBoolList)
     .define_method("capsule?", &torch::IValue::isCapsule)
@@ -39,95 +34,98 @@ void init_ivalue(Rice::Module& m) {
     .define_method("tuple?", &torch::IValue::isTuple)
     .define_method(
       "to_bool",
-      *[](torch::IValue& self) {
+      [](torch::IValue& self) {
         return self.toBool();
       })
     .define_method(
       "to_double",
-      *[](torch::IValue& self) {
+      [](torch::IValue& self) {
         return self.toDouble();
       })
     .define_method(
       "to_int",
-      *[](torch::IValue& self) {
+      [](torch::IValue& self) {
         return self.toInt();
       })
     .define_method(
       "to_list",
-      *[](torch::IValue& self) {
+      [](torch::IValue& self) {
         auto list = self.toListRef();
         Rice::Array obj;
         for (auto& elem : list) {
-          obj.push(to_ruby<torch::IValue>(torch::IValue{elem}));
+          auto v = torch::IValue{elem};
+          obj.push(Rice::Object(Rice::detail::To_Ruby<torch::IValue>().convert(v)));
         }
         return obj;
       })
     .define_method(
       "to_string_ref",
-      *[](torch::IValue& self) {
+      [](torch::IValue& self) {
         return self.toStringRef();
       })
     .define_method(
       "to_tensor",
-      *[](torch::IValue& self) {
+      [](torch::IValue& self) {
         return self.toTensor();
       })
     .define_method(
       "to_generic_dict",
-      *[](torch::IValue& self) {
+      [](torch::IValue& self) {
         auto dict = self.toGenericDict();
         Rice::Hash obj;
         for (auto& pair : dict) {
-          obj[to_ruby<torch::IValue>(torch::IValue{pair.key()})] = to_ruby<torch::IValue>(torch::IValue{pair.value()});
+          auto k = torch::IValue{pair.key()};
+          auto v = torch::IValue{pair.value()};
+          obj[Rice::Object(Rice::detail::To_Ruby<torch::IValue>().convert(k))] = Rice::Object(Rice::detail::To_Ruby<torch::IValue>().convert(v));
         }
         return obj;
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "from_tensor",
-      *[](torch::Tensor& v) {
+      [](torch::Tensor& v) {
         return torch::IValue(v);
       })
     // TODO create specialized list types?
-    .define_singleton_method(
+    .define_singleton_function(
       "from_list",
-      *[](Rice::Array obj) {
+      [](Rice::Array obj) {
         c10::impl::GenericList list(c10::AnyType::get());
         for (auto entry : obj) {
-          list.push_back(from_ruby<torch::IValue>(entry));
+          list.push_back(Rice::detail::From_Ruby<torch::IValue>().convert(entry.value()));
         }
         return torch::IValue(list);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "from_string",
-      *[](Rice::String v) {
+      [](Rice::String v) {
         return torch::IValue(v.str());
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "from_int",
-      *[](int64_t v) {
+      [](int64_t v) {
         return torch::IValue(v);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "from_double",
-      *[](double v) {
+      [](double v) {
         return torch::IValue(v);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "from_bool",
-      *[](bool v) {
+      [](bool v) {
         return torch::IValue(v);
       })
     // see https://github.com/pytorch/pytorch/blob/master/torch/csrc/jit/python/pybind_utils.h
     // createGenericDict and toIValue
-    .define_singleton_method(
+    .define_singleton_function(
       "from_dict",
-      *[](Rice::Hash obj) {
+      [](Rice::Hash obj) {
         auto key_type = c10::AnyType::get();
         auto value_type = c10::AnyType::get();
         c10::impl::GenericDict elems(key_type, value_type);
         elems.reserve(obj.size());
         for (auto entry : obj) {
-          elems.insert(from_ruby<torch::IValue>(entry.first), from_ruby<torch::IValue>((Rice::Object) entry.second));
+          elems.insert(Rice::detail::From_Ruby<torch::IValue>().convert(entry.first), Rice::detail::From_Ruby<torch::IValue>().convert((Rice::Object) entry.second));
         }
         return torch::IValue(std::move(elems));
       });

data/ext/torch/linalg.cpp

@@ -0,0 +1,13 @@
+#include <torch/torch.h>
+
+#include <rice/rice.hpp>
+
+#include "linalg_functions.h"
+#include "templates.h"
+#include "utils.h"
+
+void init_linalg(Rice::Module& m) {
+  auto rb_mLinalg = Rice::define_module_under(m, "Linalg");
+  rb_mLinalg.add_handler<torch::Error>(handle_error);
+  add_linalg_functions(rb_mLinalg);
+}

data/ext/torch/linalg_functions.h

@@ -0,0 +1,6 @@
+// generated by rake generate:functions
+// do not edit by hand
+
+#pragma once
+
+void add_linalg_functions(Rice::Module& m);

data/ext/torch/nn.cpp

@@ -1,6 +1,6 @@
 #include <torch/torch.h>
 
-#include <rice/Module.hpp>
+#include <rice/rice.hpp>
 
 #include "nn_functions.h"
 #include "templates.h"
@@ -19,74 +19,74 @@ void init_nn(Rice::Module& m) {
 
   Rice::define_module_under(rb_mNN, "Init")
     .add_handler<torch::Error>(handle_error)
-    .define_singleton_method(
+    .define_singleton_function(
       "_calculate_gain",
-      *[](NonlinearityType nonlinearity, double param) {
+      [](NonlinearityType nonlinearity, double param) {
         return torch::nn::init::calculate_gain(nonlinearity, param);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_uniform!",
-      *[](Tensor tensor, double low, double high) {
+      [](Tensor tensor, double low, double high) {
         return torch::nn::init::uniform_(tensor, low, high);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_normal!",
-      *[](Tensor tensor, double mean, double std) {
+      [](Tensor tensor, double mean, double std) {
         return torch::nn::init::normal_(tensor, mean, std);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_constant!",
-      *[](Tensor tensor, Scalar value) {
+      [](Tensor tensor, Scalar value) {
         return torch::nn::init::constant_(tensor, value);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_ones!",
-      *[](Tensor tensor) {
+      [](Tensor tensor) {
         return torch::nn::init::ones_(tensor);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_zeros!",
-      *[](Tensor tensor) {
+      [](Tensor tensor) {
         return torch::nn::init::zeros_(tensor);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_eye!",
-      *[](Tensor tensor) {
+      [](Tensor tensor) {
         return torch::nn::init::eye_(tensor);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_dirac!",
-      *[](Tensor tensor) {
+      [](Tensor tensor) {
         return torch::nn::init::dirac_(tensor);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_xavier_uniform!",
-      *[](Tensor tensor, double gain) {
+      [](Tensor tensor, double gain) {
         return torch::nn::init::xavier_uniform_(tensor, gain);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_xavier_normal!",
-      *[](Tensor tensor, double gain) {
+      [](Tensor tensor, double gain) {
         return torch::nn::init::xavier_normal_(tensor, gain);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_kaiming_uniform!",
-      *[](Tensor tensor, double a, FanModeType mode, NonlinearityType nonlinearity) {
+      [](Tensor tensor, double a, FanModeType mode, NonlinearityType nonlinearity) {
         return torch::nn::init::kaiming_uniform_(tensor, a, mode, nonlinearity);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_kaiming_normal!",
-      *[](Tensor tensor, double a, FanModeType mode, NonlinearityType nonlinearity) {
+      [](Tensor tensor, double a, FanModeType mode, NonlinearityType nonlinearity) {
         return torch::nn::init::kaiming_normal_(tensor, a, mode, nonlinearity);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_orthogonal!",
-      *[](Tensor tensor, double gain) {
+      [](Tensor tensor, double gain) {
         return torch::nn::init::orthogonal_(tensor, gain);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_sparse!",
-      *[](Tensor tensor, double sparsity, double std) {
+      [](Tensor tensor, double sparsity, double std) {
         return torch::nn::init::sparse_(tensor, sparsity, std);
       });
 
@@ -94,18 +94,18 @@ void init_nn(Rice::Module& m) {
     .add_handler<torch::Error>(handle_error)
     .define_method(
       "grad",
-      *[](Parameter& self) {
+      [](Parameter& self) {
         auto grad = self.grad();
-        return grad.defined() ? to_ruby<torch::Tensor>(grad) : Nil;
+        return grad.defined() ? Object(Rice::detail::To_Ruby<torch::Tensor>().convert(grad)) : Nil;
       })
     .define_method(
       "grad=",
-      *[](Parameter& self, torch::Tensor& grad) {
+      [](Parameter& self, torch::Tensor& grad) {
         self.mutable_grad() = grad;
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_make_subclass",
-      *[](Tensor& rd, bool requires_grad) {
+      [](Tensor& rd, bool requires_grad) {
         auto data = rd.detach();
         data.unsafeGetTensorImpl()->set_allow_tensor_metadata_change(true);
         auto var = data.set_requires_grad(requires_grad);

data/ext/torch/random.cpp

@@ -1,20 +1,20 @@
 #include <torch/torch.h>
 
-#include <rice/Module.hpp>
+#include <rice/rice.hpp>
 
 #include "utils.h"
 
 void init_random(Rice::Module& m) {
   Rice::define_module_under(m, "Random")
     .add_handler<torch::Error>(handle_error)
-    .define_singleton_method(
+    .define_singleton_function(
       "initial_seed",
-      *[]() {
+      []() {
         return at::detail::getDefaultCPUGenerator().current_seed();
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "seed",
-      *[]() {
+      []() {
         // TODO set for CUDA when available
         auto generator = at::detail::getDefaultCPUGenerator();
         return generator.seed();

data/ext/torch/ruby_arg_parser.cpp

@@ -137,7 +137,7 @@ auto FunctionParameter::check(VALUE obj, int argnum) -> bool
         return true;
       }
       if (THPVariable_Check(obj)) {
-        auto var = from_ruby<torch::Tensor>(obj);
+        auto var = Rice::detail::From_Ruby<torch::Tensor>().convert(obj);
         return !var.requires_grad() && var.dim() == 0;
       }
       return false;
@@ -147,7 +147,7 @@ auto FunctionParameter::check(VALUE obj, int argnum) -> bool
         return true;
       }
       if (THPVariable_Check(obj)) {
-        auto var = from_ruby<torch::Tensor>(obj);
+        auto var = Rice::detail::From_Ruby<torch::Tensor>().convert(obj);
         return at::isIntegralType(var.scalar_type(), /*includeBool=*/false) && !var.requires_grad() && var.dim() == 0;
       }
       return false;

data/ext/torch/ruby_arg_parser.h

@@ -5,7 +5,7 @@
 #include <sstream>
 
 #include <torch/torch.h>
-#include <rice/Exception.hpp>
+#include <rice/rice.hpp>
 
 #include "templates.h"
 #include "utils.h"
@@ -78,6 +78,7 @@ struct RubyArgs {
   inline OptionalTensor optionalTensor(int i);
   inline at::Scalar scalar(int i);
   // inline at::Scalar scalarWithDefault(int i, at::Scalar default_scalar);
+  inline std::vector<at::Scalar> scalarlist(int i);
   inline std::vector<at::Tensor> tensorlist(int i);
   template<int N>
   inline std::array<at::Tensor, N> tensorlist_n(int i);
@@ -121,7 +122,7 @@ struct RubyArgs {
 };
 
 inline at::Tensor RubyArgs::tensor(int i) {
-  return from_ruby<torch::Tensor>(args[i]);
+  return Rice::detail::From_Ruby<torch::Tensor>().convert(args[i]);
 }
 
 inline OptionalTensor RubyArgs::optionalTensor(int i) {
@@ -131,12 +132,17 @@ inline OptionalTensor RubyArgs::optionalTensor(int i) {
 
 inline at::Scalar RubyArgs::scalar(int i) {
   if (NIL_P(args[i])) return signature.params[i].default_scalar;
-  return from_ruby<torch::Scalar>(args[i]);
+  return Rice::detail::From_Ruby<torch::Scalar>().convert(args[i]);
+}
+
+inline std::vector<at::Scalar> RubyArgs::scalarlist(int i) {
+  if (NIL_P(args[i])) return std::vector<at::Scalar>();
+  return Rice::detail::From_Ruby<std::vector<at::Scalar>>().convert(args[i]);
 }
 
 inline std::vector<at::Tensor> RubyArgs::tensorlist(int i) {
   if (NIL_P(args[i])) return std::vector<at::Tensor>();
-  return from_ruby<std::vector<Tensor>>(args[i]);
+  return Rice::detail::From_Ruby<std::vector<Tensor>>().convert(args[i]);
 }
 
 template<int N>
@@ -151,7 +157,7 @@ inline std::array<at::Tensor, N> RubyArgs::tensorlist_n(int i) {
   }
   for (int idx = 0; idx < size; idx++) {
     VALUE obj = rb_ary_entry(arg, idx);
-    res[idx] = from_ruby<Tensor>(obj);
+    res[idx] = Rice::detail::From_Ruby<Tensor>().convert(obj);
   }
   return res;
 }
@@ -170,7 +176,7 @@ inline std::vector<int64_t> RubyArgs::intlist(int i) {
   for (idx = 0; idx < size; idx++) {
     VALUE obj = rb_ary_entry(arg, idx);
     if (FIXNUM_P(obj)) {
-      res[idx] = from_ruby<int64_t>(obj);
+      res[idx] = Rice::detail::From_Ruby<int64_t>().convert(obj);
     } else {
       rb_raise(rb_eArgError, "%s(): argument '%s' must be %s, but found element of type %s at pos %d",
           signature.name.c_str(), signature.params[i].name.c_str(),
@@ -210,8 +216,13 @@ inline ScalarType RubyArgs::scalartype(int i) {
     {ID2SYM(rb_intern("double")), ScalarType::Double},
     {ID2SYM(rb_intern("float64")), ScalarType::Double},
     {ID2SYM(rb_intern("complex_half")), ScalarType::ComplexHalf},
+    {ID2SYM(rb_intern("complex32")), ScalarType::ComplexHalf},
     {ID2SYM(rb_intern("complex_float")), ScalarType::ComplexFloat},
+    {ID2SYM(rb_intern("cfloat")), ScalarType::ComplexFloat},
+    {ID2SYM(rb_intern("complex64")), ScalarType::ComplexFloat},
     {ID2SYM(rb_intern("complex_double")), ScalarType::ComplexDouble},
+    {ID2SYM(rb_intern("cdouble")), ScalarType::ComplexDouble},
+    {ID2SYM(rb_intern("complex128")), ScalarType::ComplexDouble},
     {ID2SYM(rb_intern("bool")), ScalarType::Bool},
     {ID2SYM(rb_intern("qint8")), ScalarType::QInt8},
     {ID2SYM(rb_intern("quint8")), ScalarType::QUInt8},
@@ -260,7 +271,7 @@ inline c10::OptionalArray<double> RubyArgs::doublelistOptional(int i) {
   for (idx = 0; idx < size; idx++) {
     VALUE obj = rb_ary_entry(arg, idx);
     if (FIXNUM_P(obj) || RB_FLOAT_TYPE_P(obj)) {
-      res[idx] = from_ruby<double>(obj);
+      res[idx] = Rice::detail::From_Ruby<double>().convert(obj);
     } else {
       rb_raise(rb_eArgError, "%s(): argument '%s' must be %s, but found element of type %s at pos %d",
           signature.name.c_str(), signature.params[i].name.c_str(),
@@ -303,22 +314,22 @@ inline c10::optional<at::MemoryFormat> RubyArgs::memoryformatOptional(int i) {
 }
 
 inline std::string RubyArgs::string(int i) {
-  return from_ruby<std::string>(args[i]);
+  return Rice::detail::From_Ruby<std::string>().convert(args[i]);
 }
 
 inline c10::optional<std::string> RubyArgs::stringOptional(int i) {
-  if (!args[i]) return c10::nullopt;
-  return from_ruby<std::string>(args[i]);
+  if (NIL_P(args[i])) return c10::nullopt;
+  return Rice::detail::From_Ruby<std::string>().convert(args[i]);
 }
 
 inline int64_t RubyArgs::toInt64(int i) {
   if (NIL_P(args[i])) return signature.params[i].default_int;
-  return from_ruby<int64_t>(args[i]);
+  return Rice::detail::From_Ruby<int64_t>().convert(args[i]);
 }
 
 inline double RubyArgs::toDouble(int i) {
   if (NIL_P(args[i])) return signature.params[i].default_double;
-  return from_ruby<double>(args[i]);
+  return Rice::detail::From_Ruby<double>().convert(args[i]);
 }
 
 inline bool RubyArgs::toBool(int i) {

data/ext/torch/special.cpp

@@ -0,0 +1,13 @@
+#include <torch/torch.h>
+
+#include <rice/rice.hpp>
+
+#include "special_functions.h"
+#include "templates.h"
+#include "utils.h"
+
+void init_special(Rice::Module& m) {
+  auto rb_mSpecial = Rice::define_module_under(m, "Special");
+  rb_mSpecial.add_handler<torch::Error>(handle_error);
+  add_special_functions(rb_mSpecial);
+}

data/ext/torch/special_functions.h

@@ -0,0 +1,6 @@
+// generated by rake generate:functions
+// do not edit by hand
+
+#pragma once
+
+void add_special_functions(Rice::Module& m);