rubynetic 0.3.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 927177e3fbecd3934e7a5acc174fd851b0b53f31df2ab03311bb188b90c47f4b
+  data.tar.gz: 78497d7135bf6a3baa19455395b0eef89f745c1417efa506c004a9bca487d462
+SHA512:
+  metadata.gz: 9084a711875862b7770d91f06564c683c67c689999bb1477abb4e44a911edcb612c397808764dc2033117b61a75de836edc00603415cd5a9792de97004100c6e
+  data.tar.gz: 86770080fbb7c8df640d3dd16ffc048049c9092ff372ed8229ef094eff749a2b9b068516928f3ea463bab4c913268f33586439059baebd4b1fe40ad4dd374562

data/bin/console

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require_relative '../lib/torch'
+
+puts "Torch.rb консоль запущена!"
+t = Torch::Tensor.new([1, 2, 3])
+t.print

data/bin/setup_libtorch

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require "rubynetic/libtorch_installer"
+
+puts "🔧 Install LibTorch..."
+LibTorchInstaller.install
+puts "🚀 Done!"

data/ext/torch/rubynetic/Makefile

@@ -0,0 +1,270 @@
+
+SHELL = /bin/sh
+
+# V=0 quiet, V=1 verbose.  other values don't work.
+V = 0
+V0 = $(V:0=)
+Q1 = $(V:1=)
+Q = $(Q1:0=@)
+ECHO1 = $(V:1=@ :)
+ECHO = $(ECHO1:0=@ echo)
+NULLCMD = :
+
+#### Start of system configuration section. ####
+
+srcdir = .
+topdir = /Users/alex/.rvm/rubies/ruby-3.3.1/include/ruby-3.3.0
+hdrdir = $(topdir)
+arch_hdrdir = /Users/alex/.rvm/rubies/ruby-3.3.1/include/ruby-3.3.0/x86_64-darwin23
+PATH_SEPARATOR = :
+VPATH = $(srcdir):$(arch_hdrdir)/ruby:$(hdrdir)/ruby
+prefix = $(DESTDIR)/Users/alex/.rvm/rubies/ruby-3.3.1
+rubysitearchprefix = $(rubylibprefix)/$(sitearch)
+rubyarchprefix = $(rubylibprefix)/$(arch)
+rubylibprefix = $(libdir)/$(RUBY_BASE_NAME)
+exec_prefix = $(prefix)
+vendorarchhdrdir = $(vendorhdrdir)/$(sitearch)
+sitearchhdrdir = $(sitehdrdir)/$(sitearch)
+rubyarchhdrdir = $(rubyhdrdir)/$(arch)
+vendorhdrdir = $(rubyhdrdir)/vendor_ruby
+sitehdrdir = $(rubyhdrdir)/site_ruby
+rubyhdrdir = $(includedir)/$(RUBY_VERSION_NAME)
+vendorarchdir = $(vendorlibdir)/$(sitearch)
+vendorlibdir = $(vendordir)/$(ruby_version)
+vendordir = $(rubylibprefix)/vendor_ruby
+sitearchdir = $(sitelibdir)/$(sitearch)
+sitelibdir = $(sitedir)/$(ruby_version)
+sitedir = $(rubylibprefix)/site_ruby
+rubyarchdir = $(rubylibdir)/$(arch)
+rubylibdir = $(rubylibprefix)/$(ruby_version)
+sitearchincludedir = $(includedir)/$(sitearch)
+archincludedir = $(includedir)/$(arch)
+sitearchlibdir = $(libdir)/$(sitearch)
+archlibdir = $(libdir)/$(arch)
+ridir = $(datarootdir)/$(RI_BASE_NAME)
+mandir = $(datarootdir)/man
+localedir = $(datarootdir)/locale
+libdir = $(exec_prefix)/lib
+psdir = $(docdir)
+pdfdir = $(docdir)
+dvidir = $(docdir)
+htmldir = $(docdir)
+infodir = $(datarootdir)/info
+docdir = $(datarootdir)/doc/$(PACKAGE)
+oldincludedir = $(DESTDIR)/usr/include
+includedir = $(SDKROOT)$(prefix)/include
+runstatedir = $(localstatedir)/run
+localstatedir = $(prefix)/var
+sharedstatedir = $(prefix)/com
+sysconfdir = $(prefix)/etc
+datadir = $(datarootdir)
+datarootdir = $(prefix)/share
+libexecdir = $(exec_prefix)/libexec
+sbindir = $(exec_prefix)/sbin
+bindir = $(exec_prefix)/bin
+archdir = $(rubyarchdir)
+
+
+CC_WRAPPER = 
+CC = gcc
+CXX = g++ -std=gnu++11
+LIBRUBY = $(LIBRUBY_SO)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = -l$(RUBY_SO_NAME)
+LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)-static -framework CoreFoundation $(MAINLIBS)
+empty =
+OUTFLAG = -o $(empty)
+COUTFLAG = -o $(empty)
+CSRCFLAG = $(empty)
+
+RUBY_EXTCONF_H = 
+cflags   = -fdeclspec $(optflags) $(debugflags) $(warnflags)
+cxxflags = 
+optflags = -O3 -fno-fast-math
+debugflags = -ggdb3
+warnflags = -Wall -Wextra -Wextra-tokens -Wdeprecated-declarations -Wdivision-by-zero -Wdiv-by-zero -Wimplicit-function-declaration -Wimplicit-int -Wpointer-arith -Wshorten-64-to-32 -Wwrite-strings -Wold-style-definition -Wmissing-noreturn -Wno-cast-function-type -Wno-constant-logical-operand -Wno-long-long -Wno-missing-field-initializers -Wno-overlength-strings -Wno-parentheses-equality -Wno-self-assign -Wno-tautological-compare -Wno-unused-parameter -Wno-unused-value -Wunused-variable -Wmisleading-indentation -Wundef
+cppflags = 
+CCDLFLAGS = -fno-common
+CFLAGS   = $(CCDLFLAGS) -O3 -I/usr/local/opt/libyaml/include -I/usr/local/opt/libksba/include -I/usr/local/opt/readline/include -I/usr/local/opt/zlib/include -I/usr/local/opt/openssl@1.1/include $(cflags) -fno-common -pipe $(ARCH_FLAG)
+INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir)/ruby/backward -I$(hdrdir) -I$(srcdir)
+DEFS     = 
+CPPFLAGS =  -I/Users/alex/libtorch/include -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE -D_DARWIN_UNLIMITED_SELECT -D_REENTRANT $(DEFS) $(cppflags)
+CXXFLAGS = $(CCDLFLAGS) -fdeclspec -std=c++17 -I/Users/alex/libtorch/include -I/Users/alex/libtorch/include/torch/csrc/api/include -I/Users/alex/libtorch/include/ATen/core $(ARCH_FLAG)
+ldflags  = -L. -L/usr/local/opt/libyaml/lib -L/usr/local/opt/libksba/lib -L/usr/local/opt/readline/lib -L/usr/local/opt/zlib/lib -L/usr/local/opt/openssl@1.1/lib -fstack-protector-strong -L/Users/alex/libtorch/lib -ltorch -ltorch_cpu -lc10
+dldflags = -L/usr/local/opt/libyaml/lib -L/usr/local/opt/libksba/lib -L/usr/local/opt/readline/lib -L/usr/local/opt/zlib/lib -L/usr/local/opt/openssl@1.1/lib -Wl,-undefined,dynamic_lookup 
+ARCH_FLAG = 
+DLDFLAGS = $(ldflags) $(dldflags) $(ARCH_FLAG)
+LDSHARED = $(CC) -dynamic -bundle
+LDSHAREDXX = $(CXX) -dynamic -bundle
+AR = /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/ar
+EXEEXT = 
+
+RUBY_INSTALL_NAME = $(RUBY_BASE_NAME)
+RUBY_SO_NAME = ruby.3.3
+RUBYW_INSTALL_NAME = 
+RUBY_VERSION_NAME = $(RUBY_BASE_NAME)-$(ruby_version)
+RUBYW_BASE_NAME = rubyw
+RUBY_BASE_NAME = ruby
+
+arch = x86_64-darwin23
+sitearch = $(arch)
+ruby_version = 3.3.0
+ruby = $(bindir)/$(RUBY_BASE_NAME)
+RUBY = $(ruby)
+BUILTRUBY = $(bindir)/$(RUBY_BASE_NAME)
+ruby_headers = $(hdrdir)/ruby.h $(hdrdir)/ruby/backward.h $(hdrdir)/ruby/ruby.h $(hdrdir)/ruby/defines.h $(hdrdir)/ruby/missing.h $(hdrdir)/ruby/intern.h $(hdrdir)/ruby/st.h $(hdrdir)/ruby/subst.h $(arch_hdrdir)/ruby/config.h
+
+RM = rm -f
+RM_RF = rm -fr
+RMDIRS = rmdir -p
+MAKEDIRS = /usr/local/opt/coreutils/bin/gmkdir -p
+INSTALL = /usr/local/opt/coreutils/bin/ginstall -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+TOUCH = exit >
+
+#### End of system configuration section. ####
+
+preload = 
+libpath = . $(libdir) /Users/alex/libtorch/lib
+LIBPATH =  -L. -L$(libdir) -L/Users/alex/libtorch/lib
+DEFFILE = 
+
+CLEANFILES = mkmf.log
+DISTCLEANFILES = 
+DISTCLEANDIRS = 
+
+extout = 
+extout_prefix = 
+target_prefix = /rubynetic
+LOCAL_LIBS = 
+LIBS = $(LIBRUBYARG_SHARED)  -lpthread  
+ORIG_SRCS = rubynetic.cpp
+SRCS = $(ORIG_SRCS) 
+OBJS = rubynetic.o
+HDRS = 
+LOCAL_HDRS = 
+TARGET = rubynetic
+TARGET_NAME = rubynetic
+TARGET_ENTRY = Init_$(TARGET_NAME)
+DLLIB = $(TARGET).bundle
+EXTSTATIC = 
+STATIC_LIB = 
+
+TIMESTAMP_DIR = .
+BINDIR        = $(bindir)
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+HDRDIR        = $(sitehdrdir)$(target_prefix)
+ARCHHDRDIR    = $(sitearchhdrdir)$(target_prefix)
+TARGET_SO_DIR =
+TARGET_SO     = $(TARGET_SO_DIR)$(DLLIB)
+CLEANLIBS     = $(TARGET_SO) $(TARGET_SO).dSYM
+CLEANOBJS     = $(OBJS) *.bak
+TARGET_SO_DIR_TIMESTAMP = $(TIMESTAMP_DIR)/.sitearchdir.-.rubynetic.time
+
+all:    $(DLLIB)
+static: $(STATIC_LIB)
+.PHONY: all install static install-so install-rb
+.PHONY: clean clean-so clean-static clean-rb
+
+clean-static::
+clean-rb-default::
+clean-rb::
+clean-so::
+clean: clean-so clean-static clean-rb-default clean-rb
+		-$(Q)$(RM_RF) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES) .*.time
+
+distclean-rb-default::
+distclean-rb::
+distclean-so::
+distclean-static::
+distclean: clean distclean-so distclean-static distclean-rb-default distclean-rb
+		-$(Q)$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		-$(Q)$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+		-$(Q)$(RMDIRS) $(DISTCLEANDIRS) 2> /dev/null || true
+
+realclean: distclean
+install: install-so install-rb
+
+install-so: $(DLLIB) $(TARGET_SO_DIR_TIMESTAMP)
+	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+clean-static::
+	-$(Q)$(RM) $(STATIC_LIB)
+install-rb: pre-install-rb do-install-rb install-rb-default
+install-rb-default: pre-install-rb-default do-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+do-install-rb:
+do-install-rb-default:
+pre-install-rb-default:
+	@$(NULLCMD)
+$(TARGET_SO_DIR_TIMESTAMP):
+	$(Q) $(MAKEDIRS) $(@D) $(RUBYARCHDIR)
+	$(Q) $(TOUCH) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .mm .cxx .cpp .o .S
+
+.cc.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.cc.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.mm.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.mm.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.cxx.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.cxx.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.cpp.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.cpp.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.c.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.c.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.m.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.m.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+$(TARGET_SO): $(OBJS) Makefile
+	$(ECHO) linking shared-object rubynetic/$(DLLIB)
+	-$(Q)$(RM) $(@)
+	$(Q) $(LDSHAREDXX) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
+	$(Q) $(POSTLINK)
+
+
+
+$(OBJS): $(HDRS) $(ruby_headers)

data/ext/torch/rubynetic/extconf.rb

@@ -0,0 +1,32 @@
+require 'mkmf'
+require_relative '../../../lib/rubynetic/libtorch_installer'
+
+# ✅ Определяем путь установки LibTorch
+libtorch_path = ENV['LIBTORCH_INSTALL_PATH'] || "/opt/homebrew"
+
+# ✅ Проверяем, установлен ли LibTorch
+unless File.directory?("#{libtorch_path}/include/torch")
+  puts "🔄 LibTorch not found, starting installation.."
+  LibTorchInstaller.install(version: "2.1.0")
+end
+
+# ✅ Проверяем снова после установки
+unless File.directory?("#{libtorch_path}/include/torch")
+  raise "❌ Error: LibTorch not found on path #{libtorch_path}/include/torch. Check the installation!"
+end
+
+# ✅ Указываем пути для компилятора
+$CXXFLAGS += " -std=c++17"
+$CXXFLAGS += " -I#{libtorch_path}/include"
+$CXXFLAGS += " -I#{libtorch_path}/include/torch/csrc/api/include"
+$CXXFLAGS += " -I#{libtorch_path}/include/ATen/core"
+
+# ✅ Пути для линковщика
+$LDFLAGS  += " -L#{libtorch_path}/lib"
+$LDFLAGS  += " -ltorch -ltorch_cpu -lc10"
+
+# ✅ Указываем пути для `mkmf`
+dir_config("rubynetic", "#{libtorch_path}/include", "#{libtorch_path}/lib")
+
+# ✅ Создаём Makefile для компиляции расширения
+create_makefile("rubynetic/rubynetic")

data/ext/torch/rubynetic/rubynetic.cpp

@@ -0,0 +1,526 @@
+#include <ruby.h>
+#include <torch/torch.h>
+#include <vector>
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+
+// Функция для преобразования Ruby массива в std::vector<float>
+std::vector<float> flatten_array(VALUE arr)
+{
+    std::vector<float> data;
+
+    for (long i = 0; i < RARRAY_LEN(arr); i++)
+    {
+        VALUE item = rb_ary_entry(arr, i);
+
+        if (RB_TYPE_P(item, T_ARRAY))
+        {
+            std::vector<float> nested = flatten_array(item);
+            data.insert(data.end(), nested.begin(), nested.end());
+        }
+        else if (RB_TYPE_P(item, T_FLOAT) || RB_TYPE_P(item, T_FIXNUM))
+        {
+            data.push_back(NUM2DBL(item));
+        }
+        else
+        {
+            rb_raise(rb_eTypeError, "Array must contain only numbers or nested arrays");
+        }
+    }
+
+    return data;
+}
+
+extern "C" VALUE tensor_to_array(VALUE self, VALUE tensor_object)
+{
+    torch::Tensor* tensor;
+    Data_Get_Struct(tensor_object, torch::Tensor, tensor);
+
+    if (!tensor) {
+        rb_raise(rb_eRuntimeError, "tensor_to_array: Tensor is NULL!");
+        return Qnil;
+    }
+
+    try {
+        // Приводим к CPU и преобразуем в std::vector
+        auto tensor_data = tensor->contiguous().to(torch::kCPU).data_ptr<float>();
+        std::vector<float> data(tensor_data, tensor_data + tensor->numel());
+
+        // Получаем размеры
+        auto sizes = tensor->sizes();
+        if (sizes.size() == 1) {
+            // Одномерный массив
+            VALUE rb_array = rb_ary_new();
+            for (float v : data) {
+                rb_ary_push(rb_array, rb_float_new(v));
+            }
+            return rb_array;
+        } else if (sizes.size() == 2) {
+            // Двумерный массив (матрица)
+            VALUE rb_matrix = rb_ary_new();
+            int rows = sizes[0], cols = sizes[1];
+
+            for (int i = 0; i < rows; ++i) {
+                VALUE rb_row = rb_ary_new();
+                for (int j = 0; j < cols; ++j) {
+                    rb_ary_push(rb_row, rb_float_new(data[i * cols + j]));
+                }
+                rb_ary_push(rb_matrix, rb_row);
+            }
+            return rb_matrix;
+        } else {
+            rb_raise(rb_eNotImpError, "tensor_to_array: Only supports 1D and 2D tensors.");
+            return Qnil;
+        }
+    }
+    catch (const c10::Error& e) {
+        rb_raise(rb_eRuntimeError, "tensor_to_array failed: %s", e.what());
+        return Qnil;
+    }
+}
+
+
+// Функция для получения размерности тензора
+std::vector<int64_t> get_tensor_shape(VALUE arr)
+{
+    std::vector<int64_t> shape;
+
+    while (RB_TYPE_P(arr, T_ARRAY))
+    {
+        shape.push_back(RARRAY_LEN(arr));
+        arr = rb_ary_entry(arr, 0);
+    }
+
+    return shape;
+}
+
+// Функция для преобразования размера тензора в строку
+std::string tensor_size_to_string(const c10::ArrayRef<int64_t>& sizes) {
+    std::ostringstream oss;
+    oss << "[";
+    for (size_t i = 0; i < sizes.size(); ++i) {
+        oss << sizes[i];
+        if (i != sizes.size() - 1) oss << ", ";
+    }
+    oss << "]";
+    return oss.str();
+}
+
+
+extern "C" VALUE tensor_shape(VALUE self, VALUE tensor_object)
+{
+    torch::Tensor *tensor;
+    Data_Get_Struct(tensor_object, torch::Tensor, tensor);
+
+    if (!tensor)
+    {
+        rb_raise(rb_eRuntimeError, "tensor_shape: Tensor is NULL!");
+        return Qnil;
+    }
+
+    std::vector<int64_t> shape_vec = tensor->sizes().vec();
+    VALUE shape_array = rb_ary_new();
+    for (int64_t dim : shape_vec)
+    {
+        rb_ary_push(shape_array, INT2NUM(dim));
+    }
+
+    return shape_array;
+}
+
+// Создание тензора из многомерного массива
+extern "C" VALUE tensor_from_data(VALUE self, VALUE arr)
+{
+    if (!RB_TYPE_P(arr, T_ARRAY))
+    {
+        rb_raise(rb_eTypeError, "Expected an array of numbers or nested arrays");
+        return Qnil;
+    }
+
+    std::vector<float> data = flatten_array(arr);
+    std::vector<int64_t> shape = get_tensor_shape(arr);
+
+    // Создаём тензор нужной формы
+    torch::Tensor *tensor = new torch::Tensor(torch::tensor(data, torch::dtype(torch::kFloat32)).reshape(shape));
+
+    return Data_Wrap_Struct(rb_cObject, NULL, free, tensor);
+}
+
+// Вывод тензора
+extern "C" VALUE tensor_print(VALUE self, VALUE tensor_obj)
+{
+    torch::Tensor *tensor;
+    Data_Get_Struct(tensor_obj, torch::Tensor, tensor);
+
+    if (tensor == nullptr)
+    {
+        rb_raise(rb_eRuntimeError, "tensor_print: передан NULL-тензор!");
+        return Qnil;
+    }
+
+    return Qnil;
+}
+
+// Вывод тензора в стиле PyTorch
+extern "C" VALUE tensor_to_string(VALUE self, VALUE tensor_obj)
+{
+    torch::Tensor *tensor;
+    Data_Get_Struct(tensor_obj, torch::Tensor, tensor);
+
+    if (tensor == nullptr)
+    {
+        rb_raise(rb_eRuntimeError, "tensor_to_string: передан NULL-тензор!");
+        return Qnil;
+    }
+
+    std::ostringstream oss;
+    oss << "tensor([";
+
+    // Устанавливаем точность до 4 знаков после запятой
+    oss << std::fixed << std::setprecision(4);
+
+    // Получаем размерность тензора
+    std::vector<int64_t> shape = tensor->sizes().vec();
+
+    if (shape.size() == 1)
+    {
+        // ✅ 1D тензор: tensor([0.1234, 0.5678])
+        oss << "[";
+        for (int i = 0; i < shape[0]; i++)
+        {
+            oss << tensor->index({i}).item<float>();
+            if (i < shape[0] - 1)
+                oss << ", ";
+        }
+        oss << "]";
+    }
+    else
+    {
+        // ✅ 2D и выше: tensor([[0.1234, 0.5678], [0.9876, 0.4321]])
+        oss << "\n";
+        for (int i = 0; i < shape[0]; i++)
+        {
+            oss << "  [";
+            for (int j = 0; j < shape[1]; j++)
+            {
+                oss << tensor->index({i, j}).item<float>();
+                if (j < shape[1] - 1)
+                    oss << ", ";
+            }
+            oss << "]";
+            if (i < shape[0] - 1)
+                oss << ",\n";
+        }
+    }
+
+    oss << "])";
+    return rb_str_new_cstr(oss.str().c_str());
+}
+
+// Создание тензра, заполненного нулями
+extern "C" VALUE tensor_zeros(VALUE self, VALUE shape_array)
+{
+    if (!RB_TYPE_P(shape_array, T_ARRAY))
+    {
+        rb_raise(rb_eTypeError, "Expected an array of shape dimensions");
+        return Qnil;
+    }
+
+    std::vector<int64_t> shape;
+    for (long i = 0; i < RARRAY_LEN(shape_array); i++)
+    {
+        if (!RB_TYPE_P(rb_ary_entry(shape_array, i), T_FIXNUM))
+        {
+            rb_raise(rb_eTypeError, "All dimensions must be integers");
+            return Qnil;
+        }
+        shape.push_back(NUM2INT(rb_ary_entry(shape_array, i)));
+    }
+
+    if (shape.empty())
+    {
+        rb_raise(rb_eArgError, "Shape cannot be empty");
+        return Qnil;
+    }
+
+    torch::Tensor *tensor = new torch::Tensor(torch::zeros(shape));
+
+    return Data_Wrap_Struct(rb_cObject, NULL, free, tensor);
+}
+
+// Создание тензора, заполненного единицами
+extern "C" VALUE tensor_ones(VALUE self, VALUE shape_array)
+{
+    if (!RB_TYPE_P(shape_array, T_ARRAY))
+    {
+        rb_raise(rb_eTypeError, "Expected an array of shape dimensions");
+        return Qnil;
+    }
+
+    std::vector<int64_t> shape;
+    for (long i = 0; i < RARRAY_LEN(shape_array); i++)
+    {
+        shape.push_back(NUM2INT(rb_ary_entry(shape_array, i)));
+    }
+
+    torch::Tensor *tensor = new torch::Tensor(torch::ones(shape));
+
+    return Data_Wrap_Struct(rb_cObject, NULL, free, tensor);
+}
+
+// Создание тензора со случайными значениями
+extern "C" VALUE tensor_rand(int argc, VALUE *argv, VALUE self)
+{
+    if (argc < 1)
+    {
+        rb_raise(rb_eArgError, "Expected at least one argument (shape)");
+        return Qnil;
+    }
+
+    std::vector<int64_t> shape;
+    double min = 0.0, max = 1.0; // Значения по умолчанию
+
+    // Если последние 2 аргумента - числа, считаем их `min` и `max`
+    if (argc >= 3 && (RB_TYPE_P(argv[argc - 2], T_FLOAT) || RB_TYPE_P(argv[argc - 2], T_FIXNUM)) &&
+        (RB_TYPE_P(argv[argc - 1], T_FLOAT) || RB_TYPE_P(argv[argc - 1], T_FIXNUM)))
+    {
+        min = NUM2DBL(argv[argc - 2]);
+        max = NUM2DBL(argv[argc - 1]);
+        argc -= 2; // Убираем два последних аргумента
+    }
+
+    for (int i = 0; i < argc; i++)
+    {
+        if (!RB_TYPE_P(argv[i], T_FIXNUM))
+        {
+            rb_raise(rb_eTypeError, "Shape dimensions must be integers");
+            return Qnil;
+        }
+        shape.push_back(NUM2INT(argv[i]));
+    }
+
+    if (shape.empty())
+    {
+        rb_raise(rb_eArgError, "Shape cannot be empty");
+        return Qnil;
+    }
+
+    if (min >= max)
+    {
+        rb_raise(rb_eArgError, "min must be less than max");
+        return Qnil;
+    }
+
+    torch::Tensor *tensor = new torch::Tensor((max - min) * torch::rand(shape) + min);
+
+    return Data_Wrap_Struct(rb_cObject, NULL, free, tensor);
+}
+
+// Сложение тензоров (a + b)
+extern "C" VALUE tensor_add(VALUE self, VALUE tensor1_object, VALUE tensor2_object)
+{
+    torch::Tensor* tensor1;
+    torch::Tensor* tensor2;
+
+    Data_Get_Struct(tensor1_object, torch::Tensor, tensor1);
+    Data_Get_Struct(tensor2_object, torch::Tensor, tensor2);
+
+    if (!tensor1 || !tensor2) {
+        rb_raise(rb_eRuntimeError, "tensor_add: One of the tensors is NULL!");
+        return Qnil;
+    }
+
+    try {
+        // ❌ УБИРАЕМ expand() или reshape()
+        // Просто складываем тензоры, если их размеры совпадают
+        torch::Tensor* result = new torch::Tensor(*tensor1 + *tensor2);
+        return Data_Wrap_Struct(rb_cObject, NULL, free, result);
+    }
+    catch (const c10::Error& e) {
+        std::ostringstream oss;
+        oss << "tensor_add: Broadcasting failed. Tensor sizes are incompatible. Got [";
+        for (auto s : tensor1->sizes()) oss << s << " ";
+        oss << "] and [";
+        for (auto s : tensor2->sizes()) oss << s << " ";
+        oss << "]";
+
+        rb_raise(rb_eArgError, "%s", oss.str().c_str());
+        return Qnil;
+    }
+}
+
+// Вычитание тензоров (a - b)
+extern "C" VALUE tensor_sub(VALUE self, VALUE tensor1_object, VALUE tensor2_object)
+{
+    torch::Tensor* tensor1;
+    torch::Tensor* tensor2;
+
+    Data_Get_Struct(tensor1_object, torch::Tensor, tensor1);
+    Data_Get_Struct(tensor2_object, torch::Tensor, tensor2);
+
+    if (!tensor1 || !tensor2) {
+        rb_raise(rb_eRuntimeError, "tensor_sub: One of the tensors is NULL!");
+        return Qnil;
+    }
+
+    if (tensor1->sizes() != tensor2->sizes()) {
+        std::ostringstream size1, size2;
+        size1 << "[";
+        for (auto s : tensor1->sizes()) size1 << s << " ";
+        size1 << "]";
+
+        size2 << "[";
+        for (auto s : tensor2->sizes()) size2 << s << " ";
+        size2 << "]";
+
+        std::string error_message = "tensor_sub: Tensor sizes must match exactly. Got " + size1.str() + " and " + size2.str();
+        rb_raise(rb_eArgError, "%s", error_message.c_str());
+        return Qnil;
+    }
+
+    try {
+        torch::Tensor* result = new torch::Tensor(*tensor1 - *tensor2);
+        return Data_Wrap_Struct(rb_cObject, NULL, free, result);
+    }
+    catch (const c10::Error& e) {
+        rb_raise(rb_eArgError, "tensor_sub: PyTorch error during subtraction");
+        return Qnil;
+    }
+}
+
+
+// Поэлиментное умножение тензоров (a * b)
+extern "C" VALUE tensor_mul(VALUE self, VALUE tensor1_object, VALUE tensor2_object)
+{
+    torch::Tensor* tensor1;
+    torch::Tensor* tensor2;
+
+    Data_Get_Struct(tensor1_object, torch::Tensor, tensor1);
+    Data_Get_Struct(tensor2_object, torch::Tensor, tensor2);
+
+    if (!tensor1 || !tensor2) {
+        rb_raise(rb_eRuntimeError, "tensor_mul: One of the tensors is NULL!");
+        return Qnil;
+    }
+
+    try {
+        // Применяем PyTorch broadcasting через `broadcast_tensors`
+        auto tensors = torch::broadcast_tensors({*tensor1, *tensor2});
+        torch::Tensor expanded_t1 = tensors[0];
+        torch::Tensor expanded_t2 = tensors[1];
+
+        torch::Tensor* result = new torch::Tensor(expanded_t1 * expanded_t2);
+        return Data_Wrap_Struct(rb_cObject, NULL, free, result);
+    }
+    catch (const c10::Error& e) {
+        std::ostringstream oss;
+        oss << "tensor_mul: Broadcasting failed. Tensor sizes are incompatible. Got [";
+        for (auto s : tensor1->sizes()) oss << s << " ";
+        oss << "] and [";
+        for (auto s : tensor2->sizes()) oss << s << " ";
+        oss << "]";
+
+        rb_raise(rb_eArgError, "%s", oss.str().c_str());
+        return Qnil;
+    }
+}
+
+
+// Поэлиментное деление тензоров (a / b)
+extern "C" VALUE tensor_div(VALUE self, VALUE tensor1_object, VALUE tensor2_object)
+{
+    torch::Tensor* tensor1;
+    torch::Tensor* tensor2;
+
+    Data_Get_Struct(tensor1_object, torch::Tensor, tensor1);
+    Data_Get_Struct(tensor2_object, torch::Tensor, tensor2);
+
+    if (!tensor1 || !tensor2) {
+        rb_raise(rb_eRuntimeError, "tensor_div: One of the tensors is NULL!");
+        return Qnil;
+    }
+
+    try {
+        // Используем PyTorch broadcasting через `broadcast_tensors`
+        auto tensors = torch::broadcast_tensors({*tensor1, *tensor2});
+        torch::Tensor expanded_t1 = tensors[0];
+        torch::Tensor expanded_t2 = tensors[1];
+
+        // Поэлементное деление
+        torch::Tensor* result = new torch::Tensor(expanded_t1 / expanded_t2);
+        return Data_Wrap_Struct(rb_cObject, NULL, free, result);
+    }
+    catch (const c10::Error& e) {
+        std::ostringstream oss;
+        oss << "tensor_div: Broadcasting failed. Tensor sizes are incompatible. Got [";
+        for (auto s : tensor1->sizes()) oss << s << " ";
+        oss << "] and [";
+        for (auto s : tensor2->sizes()) oss << s << " ";
+        oss << "]";
+
+        rb_raise(rb_eArgError, "%s", oss.str().c_str());
+        return Qnil;
+    }
+}
+
+// Скалярное произведение (a @ b)
+extern "C" VALUE tensor_dot(VALUE self, VALUE tensor1_object, VALUE tensor2_object)
+{
+    torch::Tensor* tensor1;
+    torch::Tensor* tensor2;
+
+    Data_Get_Struct(tensor1_object, torch::Tensor, tensor1);
+    Data_Get_Struct(tensor2_object, torch::Tensor, tensor2);
+
+    if (!tensor1 || !tensor2) {
+        rb_raise(rb_eRuntimeError, "tensor_dot: One of the tensors is NULL!");
+        return Qnil;
+    }
+
+    try {
+        torch::Tensor* result;
+
+        // Если оба тензора 1D (вектора), делаем dot product
+        if (tensor1->dim() == 1 && tensor2->dim() == 1) {
+            double scalar = torch::dot(*tensor1, *tensor2).item<double>();
+            return DBL2NUM(scalar);  // ✅ Возвращаем число, а не объект!
+        }
+        // Если матричное умножение
+        else {
+            result = new torch::Tensor(torch::matmul(*tensor1, *tensor2));
+            return Data_Wrap_Struct(rb_cObject, NULL, free, result);
+        }
+    }
+    catch (const c10::Error& e) {
+        std::ostringstream oss;
+        oss << "tensor_dot: Tensors have incompatible shapes for multiplication. Got [";
+        for (auto s : tensor1->sizes()) oss << s << " ";
+        oss << "] and [";
+        for (auto s : tensor2->sizes()) oss << s << " ";
+        oss << "]";
+
+        rb_raise(rb_eArgError, "%s", oss.str().c_str());
+        return Qnil;
+    }
+}
+
+// Инициализация модуля Rubynetic
+extern "C" void Init_rubynetic()
+{
+    VALUE mRubynetic = rb_define_module("Rubynetic");
+
+    rb_define_singleton_method(mRubynetic, "tensor_from_data", RUBY_METHOD_FUNC(tensor_from_data), 1);
+    rb_define_singleton_method(mRubynetic, "tensor_print", RUBY_METHOD_FUNC(tensor_print), 1);
+    rb_define_singleton_method(mRubynetic, "tensor_to_string", RUBY_METHOD_FUNC(tensor_to_string), 1);
+    rb_define_singleton_method(mRubynetic, "tensor_zeros", RUBY_METHOD_FUNC(tensor_zeros), 1);
+    rb_define_singleton_method(mRubynetic, "tensor_ones", RUBY_METHOD_FUNC(tensor_ones), 1);
+    rb_define_singleton_method(mRubynetic, "tensor_rand", RUBY_METHOD_FUNC(tensor_rand), -1);
+    rb_define_singleton_method(mRubynetic, "tensor_to_array", RUBY_METHOD_FUNC(tensor_to_array), 1);
+    rb_define_singleton_method(mRubynetic, "tensor_add", RUBY_METHOD_FUNC(tensor_add), 2);
+    rb_define_singleton_method(mRubynetic, "tensor_sub", RUBY_METHOD_FUNC(tensor_sub), 2);
+    rb_define_singleton_method(mRubynetic, "tensor_mul", RUBY_METHOD_FUNC(tensor_mul), 2);
+    rb_define_singleton_method(mRubynetic, "tensor_div", RUBY_METHOD_FUNC(tensor_div), 2);
+    rb_define_singleton_method(mRubynetic, "tensor_dot", RUBY_METHOD_FUNC(tensor_dot), 2);
+    rb_define_singleton_method(mRubynetic, "tensor_shape", RUBY_METHOD_FUNC(tensor_shape), 1);
+}

data/lib/rubynetic/libtorch_downloader.rb

@@ -0,0 +1,82 @@
+require "open-uri"
+require "fileutils"
+require "tmpdir"
+
+module LibTorchDownloader
+  BASE_URL = "https://download.pytorch.org/libtorch"
+
+  def self.download_and_install(os, version = "2.1.0", variant = "cpu")
+    url = case os
+          when "macos"
+            "#{BASE_URL}/#{variant}/libtorch-macos-#{version}.zip"
+          when "linux"
+            "#{BASE_URL}/#{variant}/libtorch-cxx11-abi-shared-with-deps-#{version}+#{variant}.zip"
+          when "windows"
+            "#{BASE_URL}/#{variant}/libtorch-win-shared-with-deps-#{version}.zip"
+          else
+            raise "❌ OS not supported: #{os}"
+          end
+
+    install_path = File.expand_path("~/libtorch")  # 📌 Основная директория установки
+    temp_path = Dir.mktmpdir("libtorch_")  # 🟢 Временная директория для распаковки
+    zip_file = File.join(Dir.tmpdir, "libtorch.zip")
+
+    puts "📥 Downloading LibTorch #{version} (#{variant}) for #{os}..."
+    URI.open(url) do |remote_file|
+      File.open(zip_file, "wb") { |file| file.write(remote_file.read) }
+    end
+
+    puts "📦 Extracting to temp folder: #{temp_path}..."
+    FileUtils.mkdir_p(temp_path)
+
+    unless system("which unzip > /dev/null")
+      raise "❌ 'unzip' command not found. Please install unzip."
+    end
+
+    system("unzip -o #{zip_file} -d #{temp_path}")
+
+    # 📌 Определяем путь, где оказались файлы после извлечения
+    extracted_dir = "#{temp_path}/libtorch"
+    puts "🔍 Extracted files are in: #{extracted_dir}"
+
+    # 📌 Исправляем структуру директорий, если файлы оказались в `libtorch/libtorch`
+    if Dir.exist?("#{extracted_dir}/libtorch")
+      puts "🔄 Fixing extraction structure: Moving inner libtorch/* to root"
+      extracted_dir = "#{extracted_dir}/libtorch"
+    end
+
+    # 📌 Убедимся, что `install_path` существует
+    FileUtils.mkdir_p(install_path)
+
+    # 📌 Переносим файлы, но только если они существуют
+    Dir.glob("#{extracted_dir}/*").each do |file|
+      dest = File.join(install_path, File.basename(file))
+      if File.exist?(file) || File.directory?(file)
+        puts "📂 Moving: #{file} -> #{dest}"
+        FileUtils.mv(file, dest)
+      else
+        puts "⚠️ Warning: File or directory does not exist - #{file}"
+      end
+    end
+
+    puts "🛠 Setting up environment..."
+    ENV["LIBTORCH_INSTALL_PATH"] = install_path
+
+    case os
+    when "macos"
+      system("echo 'export LIBTORCH_INSTALL_PATH=#{install_path}' >> ~/.zshrc")
+      system("echo 'export DYLD_LIBRARY_PATH=#{install_path}/lib:$DYLD_LIBRARY_PATH' >> ~/.zshrc")
+    when "linux"
+      system("echo 'export LIBTORCH_INSTALL_PATH=#{install_path}' >> ~/.bashrc")
+      system("echo 'export LD_LIBRARY_PATH=#{install_path}/lib:$LD_LIBRARY_PATH' >> ~/.bashrc")
+    when "windows"
+      system("setx PATH \"#{install_path}\\lib;%PATH%\"")
+    end
+
+    puts "✅ Installation complete! LibTorch accessible at: #{install_path}"
+
+    # Очистка временных файлов
+    FileUtils.rm_rf(temp_path)
+    File.delete(zip_file) if File.exist?(zip_file)
+  end
+end

data/lib/rubynetic/libtorch_installer.rb

@@ -0,0 +1,14 @@
+require_relative "libtorch_downloader"
+
+module LibTorchInstaller
+  def self.install(version: "2.1.0", variant: "cpu")
+    os = case RbConfig::CONFIG["host_os"]
+         when /darwin/ then "macos"
+         when /mswin|mingw|cygwin/ then "windows"
+         when /linux/ then "linux"
+         else raise "❌ ОС не поддерживается!"
+         end
+
+    LibTorchDownloader.download_and_install(os, version, variant)
+  end
+end

data/lib/rubynetic/tensor.rb

@@ -0,0 +1,97 @@
+# lib/rubynetic/rubynetic.rb
+module Rubynetic
+  class Tensor
+    attr_reader :tensor
+
+    def initialize(data)
+      raise TypeError, "Expected an array, got #{data.class}" unless data.is_a?(Array)
+      @tensor = Rubynetic.tensor_from_data(data)
+    end
+
+    def self.valid_data?(data)
+      return false unless data.is_a?(Array)
+
+      # Проверяем, содержит ли массив только числа или массивы одинаковой длины
+      if data.all? { |item| item.is_a?(Numeric) }
+        return true
+      elsif data.all? { |item| item.is_a?(Array) && item.all? { |num| num.is_a?(Numeric) } }
+        return true
+      end
+
+      false
+    end
+
+    def inspect(precision = 2)
+      array = Rubynetic.tensor_to_array(@tensor) rescue @tensor
+
+      case array
+      when Float, Integer
+        return "tensor(#{format("%.#{precision}f", array)})"
+      when Array
+        if array.all? { |e| e.is_a?(Array) }
+          # ✅ Многомерный тензор (матрица)
+          formatted_values = array.map do |row|
+            "  [" + row.map { |v| format("%.#{precision}f", v) }.join(', ') + "]"
+          end
+          return "tensor([\n" + formatted_values.join("\n") + "\n])"
+        else
+          # ✅ Одномерный тензор (вектор)
+          formatted_values = array.map { |v| format("%.#{precision}f", v) }
+          return "tensor([" + formatted_values.join(', ') + "])"
+        end
+      else
+        return "tensor(#{array})"
+      end
+    end
+
+
+    def to_s
+      inspect
+    end
+
+    def print
+      puts inspect
+    end
+
+    def shape
+      Rubynetic.tensor_shape(@tensor)  # ✅ Получаем shape тензора через C++ API
+    end
+
+    def self.zeros(*shape)
+      zeros_tensor = Rubynetic.tensor_zeros(shape)
+      Tensor.allocate.tap { |t| t.instance_variable_set(:@tensor, zeros_tensor) }
+    end
+
+    def self.ones(*shape)
+      ones_tensor = Rubynetic.tensor_ones(shape)
+      Tensor.allocate.tap { |t| t.instance_variable_set(:@tensor, ones_tensor) }
+    end
+ 
+    
+  def self.rand(*shape, min: 0.0, max: 1.0)
+    rand_tensor = Rubynetic.tensor_rand(*shape.map(&:to_i), min.to_f, max.to_f)  
+    Tensor.allocate.tap { |t| t.instance_variable_set(:@tensor, rand_tensor) }
+  end
+
+  def +(other)
+    Tensor.allocate.tap { |t| t.instance_variable_set(:@tensor, Rubynetic.tensor_add(@tensor, other.tensor)) }
+  end
+
+  def -(other)
+    Tensor.allocate.tap { |t| t.instance_variable_set(:@tensor, Rubynetic.tensor_sub(@tensor, other.tensor)) }
+  end
+
+  def *(other)
+    Tensor.allocate.tap { |t| t.instance_variable_set(:@tensor, Rubynetic.tensor_mul(@tensor, other.tensor)) }
+  end
+
+  def /(other)
+    Tensor.allocate.tap { |t| t.instance_variable_set(:@tensor, Rubynetic.tensor_div(@tensor, other.tensor)) }
+  end
+
+  def dot(other)
+    Tensor.allocate.tap { |t| t.instance_variable_set(:@tensor, Rubynetic.tensor_dot(@tensor, other.tensor)) }
+  end
+
+  end
+end

data/lib/rubynetic/torch.rb

@@ -0,0 +1,18 @@
+require_relative "libtorch_installer"
+
+module Rubynetic
+  module Torch
+    RUBYNETIC_LIB_PATH = File.expand_path("../../lib/rubynetic/rubynetic.bundle", __dir__)
+
+    unless File.exist?(RUBYNETIC_LIB_PATH)
+      puts "🔧 Not found `rubynetic.bundle`, we are trying to install `LibTorch`..."
+      LibTorchInstaller.install
+    end
+
+    require RUBYNETIC_LIB_PATH
+
+    # Проверяем, что C++ методы загружены
+    raise NameError, "Not found method tensor_from_data" unless Rubynetic.respond_to?(:tensor_from_data)
+    raise NameError, "Not found method tensor_print" unless Rubynetic.respond_to?(:tensor_print)
+  end
+end

data/lib/rubynetic.rb

@@ -0,0 +1,7 @@
+# lib/rubynetic.rb
+
+require_relative "rubynetic/torch"  # <-- Подключаем Torch
+require_relative "rubynetic/tensor"
+
+module Rubynetic
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: rubynetic
+version: !ruby/object:Gem::Version
+  version: 0.3.2
+platform: ruby
+authors:
+- Alexey Cherebayev
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-03-12 00:00:00.000000000 Z
+dependencies: []
+description: This gem downloads and installs the LibTorch library for macOS, Windows,
+  and Linux, and also includes the C++ extension.
+email:
+- devalex360@email.com
+executables:
+- setup_libtorch
+extensions:
+- ext/torch/rubynetic/extconf.rb
+extra_rdoc_files: []
+files:
+- bin/console
+- bin/setup_libtorch
+- ext/torch/rubynetic/Makefile
+- ext/torch/rubynetic/extconf.rb
+- ext/torch/rubynetic/rubynetic.bundle
+- ext/torch/rubynetic/rubynetic.cpp
+- ext/torch/rubynetic/rubynetic.o
+- lib/rubynetic.rb
+- lib/rubynetic/libtorch_downloader.rb
+- lib/rubynetic/libtorch_installer.rb
+- lib/rubynetic/tensor.rb
+- lib/rubynetic/torch.rb
+homepage: https://github.com/AlexChe360/Rubynetic
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.9
+signing_key:
+specification_version: 4
+summary: Automatic installation of LibTorch for Ruby
+test_files: []