grx-tensor 0.1.0 → 0.2.1

data/ext/grx/grx_core.h

@@ -1,5 +1,8 @@
 /*
- * grx_core.h — API pública del núcleo C de GRX
+ * grx_core.h — API publica del nucleo C de GRX
+ * =============================================================
+ * Compatible con compilacion universal y despacho dinamico SIMD
+ * (AVX2 + FMA / SSE / Escalar C)
  * =============================================================
  */
 
@@ -18,20 +21,24 @@
 extern "C" {
 #endif
 
+/* ---- Diagnostico y nivel SIMD ----------------------------------- */
+/* Retorna 2 para AVX2+FMA, 1 para SSE, 0 para Escalar portable C */
+GRX_API int grx_simd_level(void);
+
 /* ---- Memoria alineada -------------------------------------------- */
 GRX_API double* grx_alloc(size_t n);
 GRX_API void    grx_free(double *ptr);
 
-/* ---- Element-wise aritmética ------------------------------------- */
-GRX_API void grx_add   (const double *a, const double *b, double *out, size_t n);
-GRX_API void grx_sub   (const double *a, const double *b, double *out, size_t n);
-GRX_API void grx_mul   (const double *a, const double *b, double *out, size_t n);
-GRX_API void grx_div   (const double *a, const double *b, double *out, size_t n);
-GRX_API void grx_scale (const double *a, double s,        double *out, size_t n);
-GRX_API void grx_negate(const double *a,                  double *out, size_t n);
-GRX_API void grx_add_scalar(const double *a, double s,    double *out, size_t n);
+/* ---- Element-wise aritmetica ------------------------------------- */
+GRX_API void grx_add       (const double *a, const double *b, double *out, size_t n);
+GRX_API void grx_sub       (const double *a, const double *b, double *out, size_t n);
+GRX_API void grx_mul       (const double *a, const double *b, double *out, size_t n);
+GRX_API void grx_div       (const double *a, const double *b, double *out, size_t n);
+GRX_API void grx_scale     (const double *a, double s,        double *out, size_t n);
+GRX_API void grx_negate    (const double *a,                  double *out, size_t n);
+GRX_API void grx_add_scalar(const double *a, double s,        double *out, size_t n);
 
-/* ---- Element-wise matemáticas ------------------------------------ */
+/* ---- Element-wise matematicas ------------------------------------ */
 GRX_API void grx_abs    (const double *a, double *out, size_t n);
 GRX_API void grx_sqrt   (const double *a, double *out, size_t n);
 GRX_API void grx_log    (const double *a, double *out, size_t n);
@@ -46,7 +53,7 @@ GRX_API double grx_mean(const double *a, size_t n);
 GRX_API double grx_max (const double *a, size_t n);
 GRX_API double grx_min (const double *a, size_t n);
 
-/* ---- Álgebra lineal ---------------------------------------------- */
+/* ---- Algebra lineal ---------------------------------------------- */
 GRX_API double grx_dot    (const double *a, const double *b, size_t n);
 GRX_API void   grx_matmul (const double *a, const double *b, double *out,
                             size_t M, size_t K, size_t N);
@@ -63,7 +70,7 @@ GRX_API void grx_softmax     (const double *a, double *out, size_t n);
 GRX_API void grx_sgd_step(double *param, const double *grad,
                            double lr, size_t n);
 
-/* Adam: actualiza param, m, v in-place */
+/* Adam: actualiza param, m, v in-place con aceleracion FMA */
 GRX_API void grx_adam_step(double *param,
                             double *m, double *v,
                             const double *grad,
@@ -71,13 +78,16 @@ GRX_API void grx_adam_step(double *param,
                             double epsilon, double beta1t, double beta2t,
                             size_t n);
 
-/* ---- Inicialización de pesos ------------------------------------- */
+/* ---- Inicializacion de pesos ------------------------------------- */
 /* Xavier uniform: U(-limit, limit), limit = sqrt(6 / (fan_in + fan_out)) */
 GRX_API void grx_init_xavier_uniform(double *out, size_t n,
                                       size_t fan_in, size_t fan_out);
 /* He normal: N(0, sqrt(2/fan_in)) */
 GRX_API void grx_init_he_normal(double *out, size_t n, size_t fan_in);
 
+/* Extension init for Ruby */
+GRX_API void Init_grx_core(void);
+
 #ifdef __cplusplus
 }
 #endif

data/ext/unix/Makefile

@@ -1,17 +1,9 @@
 # =============================================================
 # Makefile — Linux / macOS
-#
-# Compila grx_core.c DIRECTAMENTE en lib/grx/ (sin archivo intermedio).
-# No hay .so en ext/unix/ — el único binario vive en lib/grx/.
-#
-# Uso:
-#   make          → compila (detecta OS y SIMD automáticamente)
-#   make clean    → elimina el binario de lib/grx/
-#   make bench    → compila y corre el benchmark
 # =============================================================
 
-CC      = gcc
-CFLAGS  = -O3 -march=native -ffast-math -funroll-loops \
+CC      ?= gcc
+CFLAGS  = -O3 -ffast-math -funroll-loops \
           -fPIC -fvisibility=hidden \
           -Wall -Wextra -std=c11
 LDFLAGS = -lm
@@ -19,7 +11,6 @@ SRC_DIR = ../grx
 SRC     = $(SRC_DIR)/grx_core.c
 HEADER  = $(SRC_DIR)/grx_core.h
 
-# Destino final — directamente en lib/grx/
 OUT_DIR = ../../lib/grx
 
 UNAME := $(shell uname -s)
@@ -33,21 +24,6 @@ endif
 
 TARGET = $(OUT_DIR)/$(LIB)
 
-# Detección de SIMD
-AVX2_TEST := $(shell echo 'int main(){}' | $(CC) -mavx2 -mfma -x c - -o /dev/null 2>&1)
-ifeq ($(AVX2_TEST),)
-    CFLAGS += -mavx2 -mfma
-    $(info [GRX] AVX2 + FMA habilitados — máxima velocidad SIMD)
-else
-    SSE2_TEST := $(shell echo 'int main(){}' | $(CC) -msse2 -x c - -o /dev/null 2>&1)
-    ifeq ($(SSE2_TEST),)
-        CFLAGS += -msse2
-        $(info [GRX] SSE2 habilitado)
-    else
-        $(info [GRX] Sin SIMD — modo escalar)
-    endif
-endif
-
 .PHONY: all clean bench
 
 all: $(TARGET)
@@ -55,7 +31,7 @@ all: $(TARGET)
 $(TARGET): $(SRC) $(HEADER)
 	@mkdir -p $(OUT_DIR)
 	$(CC) $(CFLAGS) $(SHARED) $(SRC) -o $(TARGET) $(LDFLAGS)
-	@echo "[GRX] Compilado → $(TARGET)"
+	@echo "[GRX] Compilado exitosamente → $(TARGET)"
 
 bench: all
 	@echo "[GRX] Corriendo benchmark..."

data/ext/windows/Makefile.mingw

@@ -1,41 +1,21 @@
 # =============================================================
 # Makefile.mingw — Windows (MinGW-w64 / MSYS2)
-#
-# Compila grx_core.c DIRECTAMENTE en lib/grx/ (sin archivo intermedio).
-# El único .dll vive en lib/grx/grx_core.dll
-#
-# Requisitos:
-#   MSYS2: pacman -S mingw-w64-x86_64-gcc
-#
-# Uso:
-#   make -f Makefile.mingw          → compila
-#   make -f Makefile.mingw clean    → elimina el .dll de lib/grx/
 # =============================================================
 
-CC      = x86_64-w64-mingw32-gcc
-CFLAGS  = -O3 -march=native -ffast-math -funroll-loops \
+CC      ?= x86_64-w64-mingw32-gcc
+CFLAGS  = -O3 -ffast-math -funroll-loops \
           -Wall -Wextra -std=c11
 LDFLAGS = -lm
 SRC_DIR = ../grx
 SRC     = $(SRC_DIR)/grx_core.c
 HEADER  = $(SRC_DIR)/grx_core.h
 
-# Destino final — directamente en lib/grx/
 OUT_DIR = ../../lib/grx
 LIB     = grx_core.dll
 TARGET  = $(OUT_DIR)/$(LIB)
 
-# __declspec(dllexport) ya está en el header vía GRX_API
 SHARED  = -shared -Wl,--out-implib,$(OUT_DIR)/libgrx_core.a
 
-AVX2_TEST := $(shell echo 'int main(){}' | $(CC) -mavx2 -mfma -x c - -o NUL 2>&1)
-ifeq ($(AVX2_TEST),)
-    CFLAGS += -mavx2 -mfma
-    $(info [GRX] AVX2 + FMA habilitados)
-else
-    $(info [GRX] Sin AVX2 — modo escalar)
-endif
-
 .PHONY: all clean
 
 all: $(TARGET)
@@ -43,7 +23,7 @@ all: $(TARGET)
 $(TARGET): $(SRC) $(HEADER)
 	mkdir -p $(OUT_DIR)
 	$(CC) $(CFLAGS) $(SHARED) $(SRC) -o $(TARGET) $(LDFLAGS)
-	@echo [GRX] Compilado → $(TARGET)
+	@echo [GRX] Compilado exitosamente → $(TARGET)
 
 clean:
 	rm -f "$(TARGET)" "$(OUT_DIR)/libgrx_core.a" 2>/dev/null || true

data/grx-tensor.gemspec

@@ -5,14 +5,15 @@ require_relative "lib/grx/version"
 Gem::Specification.new do |spec|
   spec.name          = "grx-tensor"
   spec.version       = GRX::VERSION
-  spec.authors       = ["Angel Gabriel Garcia Razo"]
+  spec.authors       = ["Razo"]
   spec.email         = ["garabatoangelopolis@gmail.com"]
 
   spec.summary       = "Tensor framework for Ruby with autograd and a C+SIMD compute core"
   spec.description   = <<~DESC
     GRX brings PyTorch-style tensor operations to Ruby. Every arithmetic op,
-    activation, and optimizer step runs through a native C library compiled
-    with AVX2+FMA SIMD. Ruby is the interface — C does the work.
+    activation, and optimizer step runs through a native C library with
+    dynamic multi-target SIMD dispatch (AVX2+FMA, SSE, and scalar fallback).
+    Ruby is the interface — C does the work.
 
     Features: autograd, SGD/Adam optimizers, Linear/Sequential/Dropout/BatchNorm
     layers, MSE/BCE/CrossEntropy loss functions, Xavier and He weight init.
@@ -37,47 +38,52 @@ Gem::Specification.new do |spec|
     "ext/windows/Makefile.mingw",
     "*.gemspec",
     "README.md",
+    "README.es.md",
+    "GUIA_PRINCIPIANTES.md",
     "LICENSE.txt",
     "CHANGELOG.md"
-  ]
+  ].reject { |f| f.match?(/\.(so|dll|dylib|bundle|a)$/) }
 
   spec.require_paths = ["lib"]
 
-  # rake-compiler compiles ext/grx/extconf.rb on `gem install`
+  # rake-compiler / rubygems compiles ext/grx/extconf.rb on `gem install`
   spec.extensions = ["ext/grx/extconf.rb"]
 
   spec.post_install_message = <<~MSG
 
-    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-      GRX-Tensor #{GRX::VERSION} installed
-    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-    Compile the C extension to enable AVX2+FMA SIMD:
-
-      Linux / macOS:  make -C ext/unix
-      Windows:        make -C ext/windows -f Makefile.mingw
-
-    Without it, GRX runs in pure Ruby fallback mode (slower but correct).
-
-    Quick start:
-
-      require "grx"
-
-      a = GRX.tensor([1.0, 2.0, 3.0], [3], requires_grad: true)
-      b = GRX.tensor([4.0, 5.0, 6.0], [3], requires_grad: true)
-      c = a + b
-      c.backward
-      puts a.grad.to_a   # [1.0, 1.0, 1.0]
-
-      net = GRX::NN::Sequential.new(
-        GRX::NN::Linear.new(4, 16),
-        GRX::NN::ReLU.new,
-        GRX::NN::Linear.new(16, 1)
-      )
-      opt = GRX::Optim::Adam.new(net.parameters, lr: 0.001)
-
-    Docs: https://github.com/Gabo-Razo/grx-tensor
-    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    ============================================================
+      GRX-Tensor #{GRX::VERSION}
+    ============================================================
+
+      [ENGLISH]
+      Thank you for choosing and using GRX-Tensor!
+
+      * Native C acceleration with dynamic SIMD dispatch
+        (AVX2+FMA, SSE, and portable scalar C) is built and
+        configured automatically.
+      * Windows Note: Native C acceleration is supported when
+        using RubyInstaller with DevKit (MSYS2 / MinGW-w64).
+        Standalone pre-compiled Windows binaries are currently
+        in active development.
+      * Documentation, guides, and tutorials:
+        https://github.com/Gabo-Razo/grx-tensor
+
+      ----------------------------------------------------------
+
+      [ESPAÑOL]
+      Muchas gracias por elegir y utilizar GRX-Tensor!
+
+      * La aceleracion nativa en C con despacho dinamico SIMD
+        (AVX2+FMA, SSE y C escalar portable) se compila y
+        configura de forma totalmente automatica.
+      * Nota para Windows: La aceleracion nativa esta soportada
+        al utilizar RubyInstaller con DevKit (MSYS2 / MinGW-w64).
+        Los binarios pre-compilados independientes para Windows
+        se encuentran actualmente en desarrollo activo.
+      * Documentacion, guias y tutoriales:
+        https://github.com/Gabo-Razo/grx-tensor
+
+    ============================================================
 
   MSG
 

data/lib/grx/c_api.rb

@@ -2,54 +2,78 @@
 
 require "fiddle"
 require "fiddle/import"
+require "rbconfig"
 
 module GRX
   module CAPI
     extend Fiddle::Importer
 
-    LIB_NAME = case RUBY_PLATFORM
-               when /mingw|mswin|windows/i then "grx_core.dll"
-               when /darwin/i              then "libgrx_core.dylib"
-               else                             "libgrx_core.so"
-               end
-
-    # rake-compiler siempre genera el archivo como "grx_core.so" / "grx_core.bundle" / "grx_core.dll"
-    # (sin el prefijo "lib"), y lo pone un nivel arriba de lib/grx/
-    RAKE_COMPILER_NAME = case RUBY_PLATFORM
-                         when /mingw|mswin|windows/i then "grx_core.dll"
-                         when /darwin/i              then "grx_core.bundle"
-                         else                             "grx_core.so"
-                         end
-
-    LIB_PATHS = [
-      # 1. make -C ext/unix  →  lib/grx/libgrx_core.so
-      File.expand_path(LIB_NAME, __dir__),
-      # 2. gem install (rake-compiler)  →  lib/grx_core.so  (un nivel arriba)
-      File.expand_path("../#{RAKE_COMPILER_NAME}", __dir__),
-      # 3. gem install en Ruby versioned path  →  lib/ruby/X.X.X/grx_core.so
-      File.expand_path("../../#{RAKE_COMPILER_NAME}", __dir__),
-      # 4. desarrollo local sin instalar
-      File.expand_path("../../ext/grx/#{LIB_NAME}", __dir__),
-    ].freeze
+    CANDIDATE_NAMES = case RUBY_PLATFORM
+                      when /mingw|mswin|windows/i
+                        ["grx_core.dll", "libgrx_core.dll", "grx_core.so", "libgrx_core.so"]
+                      when /darwin/i
+                        ["libgrx_core.dylib", "grx_core.bundle", "libgrx_core.so", "grx_core.so"]
+                      else
+                        ["libgrx_core.so", "grx_core.so", "libgrx_core.dylib", "grx_core.dll"]
+                      end
+
+    # Search directories including standard Gem extension build paths
+    SEARCH_DIRS = begin
+      dirs = [
+        File.expand_path(__dir__),                     # lib/grx/
+        File.expand_path("..", __dir__),              # lib/
+        File.expand_path("../../ext/grx", __dir__),    # ext/grx/
+        File.expand_path("../../ext/unix", __dir__),   # ext/unix/
+        File.expand_path("../../ext/windows", __dir__) # ext/windows/
+      ]
+
+      # Gem extensions build directory (RubyGems standard)
+      if defined?(Gem) && Gem.loaded_specs["grx-tensor"]
+        ext_dir = Gem.loaded_specs["grx-tensor"].extension_dir
+        dirs << ext_dir if ext_dir && File.directory?(ext_dir)
+        dirs << File.join(ext_dir, "grx") if ext_dir && File.directory?(File.join(ext_dir, "grx"))
+      end
+
+      # Ruby sitearch / vendorarch directories
+      sitearch = RbConfig::CONFIG["sitearchdir"]
+      dirs << sitearch if sitearch && File.directory?(sitearch)
+
+      dirs.uniq.freeze
+    end
+
+    LIB_PATHS = SEARCH_DIRS.flat_map do |dir|
+      CANDIDATE_NAMES.flat_map do |name|
+        [
+          File.join(dir, name),
+          File.join(dir, name).tr("/", "\\")
+        ]
+      end
+    end.uniq.freeze
+
+    LOADED_PATH = LIB_PATHS.find { |p| File.file?(p) && File.exist?(p) }
 
     LOADED = begin
-      path = LIB_PATHS.find { |p| File.exist?(p) }
-      raise Fiddle::DLError, "No se encontró #{LIB_NAME} en #{LIB_PATHS.inspect}" unless path
-      dlload path
-      true
+      if LOADED_PATH
+        dlload LOADED_PATH
+        true
+      else
+        false
+      end
     rescue Fiddle::DLError => e
-      warn "[GRX] Extensión C no disponible: #{e.message}\n" \
-           "      → Ejecuta: make -C ext/unix install\n" \
-           "      → Corriendo en modo Ruby puro (sin SIMD)."
+      warn "[GRX] C extension load error: #{e.message}\n" \
+           "      -> Running in pure Ruby fallback mode."
       false
     end
 
     if LOADED
-      # Memoria
+      # CPU SIMD Level
+      extern "int grx_simd_level(void)"
+
+      # Memory management
       extern "double* grx_alloc(size_t)"
       extern "void    grx_free(double*)"
 
-      # Aritmética element-wise
+      # Element-wise arithmetic
       extern "void grx_add       (double*, double*, double*, size_t)"
       extern "void grx_sub       (double*, double*, double*, size_t)"
       extern "void grx_mul       (double*, double*, double*, size_t)"
@@ -58,7 +82,7 @@ module GRX
       extern "void grx_add_scalar(double*, double,  double*, size_t)"
       extern "void grx_negate    (double*, double*, size_t)"
 
-      # Matemáticas element-wise
+      # Element-wise math
       extern "void grx_abs   (double*, double*, size_t)"
       extern "void grx_sqrt  (double*, double*, size_t)"
       extern "void grx_square(double*, double*, size_t)"
@@ -67,30 +91,42 @@ module GRX
       extern "void grx_pow   (double*, double,  double*, size_t)"
       extern "void grx_clip  (double*, double, double, double*, size_t)"
 
-      # Reducciones
+      # Reductions
       extern "double grx_sum (double*, size_t)"
       extern "double grx_mean(double*, size_t)"
       extern "double grx_max (double*, size_t)"
       extern "double grx_min (double*, size_t)"
 
-      # Álgebra lineal
+      # Linear algebra
       extern "double grx_dot    (double*, double*, size_t)"
       extern "void   grx_matmul (double*, double*, double*, size_t, size_t, size_t)"
 
-      # Activaciones
+      # Activations
       extern "void grx_relu       (double*, double*, size_t)"
       extern "void grx_leaky_relu (double*, double, double*, size_t)"
       extern "void grx_tanh_act   (double*, double*, size_t)"
       extern "void grx_sigmoid    (double*, double*, size_t)"
       extern "void grx_softmax    (double*, double*, size_t)"
 
-      # Optimizadores
+      # Optimizers
       extern "void grx_sgd_step (double*, double*, double, size_t)"
       extern "void grx_adam_step(double*, double*, double*, double*, double, double, double, double, double, double, size_t)"
 
-      # Inicialización de pesos
+      # Weight initialization
       extern "void grx_init_xavier_uniform(double*, size_t, size_t, size_t)"
       extern "void grx_init_he_normal     (double*, size_t, size_t)"
     end
+
+    def self.simd_mode
+      return :ruby unless LOADED
+
+      case grx_simd_level
+      when 2 then :avx2
+      when 1 then :sse
+      else :scalar
+      end
+    rescue StandardError
+      :scalar
+    end
   end
 end

data/lib/grx/data.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module GRX
+  module Data
+    # ================================================================
+    # Dataset — Base class for data collections
+    # ================================================================
+    class Dataset
+      def size
+        raise NotImplementedError, "#{self.class}#size must be implemented"
+      end
+
+      def [](index)
+        raise NotImplementedError, "#{self.class}#[] must be implemented"
+      end
+    end
+
+    # ================================================================
+    # TensorDataset — Dataset wrapping parallel tensors (e.g. X and Y)
+    # ================================================================
+    class TensorDataset < Dataset
+      attr_reader :tensors, :size
+
+      def initialize(*tensors)
+        raise ArgumentError, "Must provide at least one tensor" if tensors.empty?
+        first_dim = tensors.first.shape[0]
+        unless tensors.all? { |t| t.shape[0] == first_dim }
+          raise ArgumentError, "All tensors must have the same size in batch dimension (dimension 0)"
+        end
+        @tensors = tensors
+        @size = first_dim
+      end
+
+      def [](index)
+        @tensors.map do |t|
+          cols = t.numel / @size
+          offset = index * cols
+          data = t.to_a.slice(offset, cols)
+          new_shape = t.shape.size == 1 ? [1] : [1] + t.shape[1..]
+          Tensor.create(data, new_shape)
+        end
+      end
+    end
+
+    # ================================================================
+    # DataLoader — Mini-batch iterator with optional shuffling
+    # ================================================================
+    class DataLoader
+      include Enumerable
+
+      attr_reader :dataset, :batch_size, :shuffle
+
+      def initialize(dataset, batch_size: 32, shuffle: true)
+        @dataset    = dataset
+        @batch_size = batch_size
+        @shuffle    = shuffle
+      end
+
+      def each
+        return to_enum(:each) unless block_given?
+
+        indices = (0...@dataset.size).to_a
+        indices.shuffle! if @shuffle
+
+        indices.each_slice(@batch_size) do |batch_indices|
+          batch_samples = batch_indices.map { |i| @dataset[i] }
+          num_tensors = batch_samples.first.size
+
+          batched = (0...num_tensors).map do |t_idx|
+            slices = batch_samples.map { |sample| sample[t_idx].to_a }
+            flat_data = slices.flatten
+            sample_shape = batch_samples.first[t_idx].shape
+            batch_dim = batch_indices.size
+            target_shape = [batch_dim] + sample_shape[1..]
+            Tensor.create(flat_data, target_shape)
+          end
+
+          yield(*batched)
+        end
+      end
+
+      def size
+        (@dataset.size.to_f / @batch_size).ceil
+      end
+    end
+  end
+end