grx-tensor 0.2.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

@@ -11,8 +11,9 @@ Gem::Specification.new do |spec|
   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.
@@ -45,41 +46,44 @@ Gem::Specification.new do |spec|
 
   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,6 +2,7 @@
 
 require "fiddle"
 require "fiddle/import"
+require "rbconfig"
 
 module GRX
   module CAPI
@@ -9,20 +10,36 @@ module GRX
 
     CANDIDATE_NAMES = case RUBY_PLATFORM
                       when /mingw|mswin|windows/i
-                        ["grx_core.dll", "libgrx_core.dll", "libgrx_core.so", "grx_core.so"]
+                        ["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_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/
-    ].freeze
+    # 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|
@@ -33,22 +50,25 @@ module GRX
       end
     end.uniq.freeze
 
+    LOADED_PATH = LIB_PATHS.find { |p| File.file?(p) && File.exist?(p) }
+
     LOADED = begin
-      path = LIB_PATHS.find { |p| File.file?(p) && File.exist?(p) }
-      if path
-        dlload path
+      if LOADED_PATH
+        dlload LOADED_PATH
         true
       else
-        raise Fiddle::DLError, "Binary library not found (#{CANDIDATE_NAMES.join(', ')}) in #{SEARCH_DIRS.inspect}"
+        false
       end
     rescue Fiddle::DLError => e
-      warn "[GRX] C extension unavailable: #{e.message}\n" \
-           "      → Run: make -C ext/unix all (Linux/macOS) or make -C ext/windows -f Makefile.mingw all (Windows)\n" \
-           "      → Running in pure Ruby fallback mode (without SIMD)."
+      warn "[GRX] C extension load error: #{e.message}\n" \
+           "      -> Running in pure Ruby fallback mode."
       false
     end
 
     if LOADED
+      # CPU SIMD Level
+      extern "int grx_simd_level(void)"
+
       # Memory management
       extern "double* grx_alloc(size_t)"
       extern "void    grx_free(double*)"
@@ -96,5 +116,17 @@ module GRX
       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/nn.rb

@@ -147,8 +147,10 @@ module GRX
     end
 
     class LeakyReLU < Module
-      def initialize(alpha = 0.01)
-        @alpha = alpha
+      attr_reader :alpha
+
+      def initialize(alpha_arg = nil, alpha: nil)
+        @alpha = (alpha || alpha_arg || 0.01).to_f
       end
       def forward(x) = x.leaky_relu(@alpha)
       def to_s = "LeakyReLU(alpha=#{@alpha})"
@@ -242,10 +244,10 @@ module GRX
     class LayerNorm < Module
       attr_reader :gamma, :beta, :normalized_shape, :epsilon
 
-      def initialize(normalized_shape, epsilon: 1e-5)
+      def initialize(normalized_shape, eps: nil, epsilon: 1e-5)
         @normalized_shape = normalized_shape.is_a?(Array) ? normalized_shape : [normalized_shape]
         @dim              = @normalized_shape.reduce(1, :*)
-        @epsilon          = epsilon
+        @epsilon          = (eps || epsilon).to_f
 
         @gamma = Tensor.ones(@normalized_shape, requires_grad: true)
         @beta  = Tensor.zeros(@normalized_shape, requires_grad: true)
@@ -318,10 +320,10 @@ module GRX
     # BatchNorm1d — Normalizacion por batch
     # ================================================================
     class BatchNorm1d < Module
-      def initialize(num_features, epsilon: 1e-5, momentum: 0.1)
+      def initialize(num_features, eps: nil, epsilon: 1e-5, momentum: 0.1)
         @num_features = num_features
-        @epsilon      = epsilon
-        @momentum     = momentum
+        @epsilon      = (eps || epsilon).to_f
+        @momentum     = momentum.to_f
         @training     = true
 
         @gamma = Tensor.ones([num_features],  requires_grad: true)

data/lib/grx/optim.rb

@@ -54,14 +54,19 @@ module GRX
     # The standard optimizer for deep neural networks.
     # ================================================================
     class Adam
-      def initialize(params, lr: 0.001, beta1: 0.9, beta2: 0.999,
-                     epsilon: 1e-8, weight_decay: 0.0)
+      def initialize(params, lr: 0.001, betas: nil, beta1: 0.9, beta2: 0.999,
+                     eps: nil, epsilon: 1e-8, weight_decay: 0.0)
         @params       = params
-        @lr           = lr
-        @beta1        = beta1
-        @beta2        = beta2
-        @epsilon      = epsilon
-        @weight_decay = weight_decay
+        @lr           = lr.to_f
+        if betas
+          @beta1 = betas[0].to_f
+          @beta2 = betas[1].to_f
+        else
+          @beta1 = beta1.to_f
+          @beta2 = beta2.to_f
+        end
+        @epsilon      = eps ? eps.to_f : epsilon.to_f
+        @weight_decay = weight_decay.to_f
         @t            = 0  # current step
 
         # First and second order moment vectors (zero-initialized)

data/lib/grx/storage.rb

@@ -7,19 +7,20 @@ module GRX
   # Storage — Native memory buffer
   #
   # When CAPI is loaded:
-  #   @ptr  → Fiddle::Pointer to 32-byte aligned doubles block
+  #   @ptr  -> Fiddle::Pointer to 32-byte aligned doubles block
   #           allocated via grx_alloc() (C posix_memalign / _aligned_malloc).
   #           Data lives in C heap, NOT managed by Ruby GC.
   #
   # When CAPI is NOT loaded (fallback):
-  #   @data → Standard Ruby Array (slow but correct).
+  #   @data -> Standard Ruby Array (slow but correct).
   # ===================================================================
   class Storage
     attr_reader :size
     attr_reader :ptr
 
     def initialize(array_plano)
-      @size = array_plano.size
+      flat = array_plano.is_a?(Array) ? array_plano.flatten : Array(array_plano)
+      @size = flat.size
 
       if CAPI::LOADED
         # Fast mode: aligned C memory
@@ -27,7 +28,7 @@ module GRX
         raise StorageError, "grx_alloc failed (OOM)" if @ptr.null?
 
         # Pack Ruby Array into C buffer as IEEE 754 doubles
-        bytes = array_plano.pack("d*")
+        bytes = flat.map(&:to_f).pack("d*")
         @ptr[0, bytes.bytesize] = bytes
 
         # Finalizer releases C memory upon Ruby GC collection
@@ -35,7 +36,7 @@ module GRX
         ObjectSpace.define_finalizer(self, self.class.make_finalizer(ptr_to_free))
       else
         # Fallback mode: Ruby Array
-        @data = array_plano.map(&:to_f)
+        @data = flat.map(&:to_f)
         @ptr  = nil
       end
     end

data/lib/grx/tensor.rb

@@ -345,6 +345,34 @@ module GRX
       end
     end
 
+    def argmax
+      arr = to_a
+      return 0 if arr.empty?
+      max_idx = 0
+      max_val = arr[0]
+      (1...arr.size).each do |i|
+        if arr[i] > max_val
+          max_val = arr[i]
+          max_idx = i
+        end
+      end
+      max_idx
+    end
+
+    def argmin
+      arr = to_a
+      return 0 if arr.empty?
+      min_idx = 0
+      min_val = arr[0]
+      (1...arr.size).each do |i|
+        if arr[i] < min_val
+          min_val = arr[i]
+          min_idx = i
+        end
+      end
+      min_idx
+    end
+
     # ----------------------------------------------------------------
     # LINEAR ALGEBRA
     # ----------------------------------------------------------------
@@ -538,6 +566,10 @@ module GRX
       @storage.read(_calc_flat_index(coords))
     end
 
+    def set(*coords, val)
+      @storage.write(_calc_flat_index(coords), val.to_f)
+    end
+
     def contiguous
       return self if _contiguous?
       c = Tensor.create(to_a, @shape, requires_grad: @requires_grad)
@@ -614,6 +646,10 @@ module GRX
       @shape.reduce(1, :*)
     end
 
+    def rank
+      @shape.size
+    end
+
     def to_a
       # If strides are contiguous (normal tensor, reshape), read buffer directly.
       # Otherwise (transpose, strided views), traverse with custom strides.

data/lib/grx/utils.rb

@@ -24,5 +24,20 @@ module GRX
       end
       total_norm
     end
+
+    # ================================================================
+    # one_hot — Generates a 2D One-Hot encoded Tensor from class indices
+    # ================================================================
+    def self.one_hot(indices, num_classes: nil, requires_grad: false)
+      ids = indices.is_a?(Tensor) ? indices.to_a.map(&:to_i) : Array(indices).map(&:to_i)
+      c = num_classes || (ids.empty? ? 0 : ids.max + 1)
+      n = ids.size
+      matrix_data = Array.new(n * c, 0.0)
+      ids.each_with_index do |class_id, row|
+        raise IndexError, "Class index #{class_id} out of bounds [0, #{c})" if class_id < 0 || class_id >= c
+        matrix_data[row * c + class_id] = 1.0
+      end
+      Tensor.create(matrix_data, [n, c], requires_grad: requires_grad)
+    end
   end
 end

data/lib/grx/version.rb

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

data/lib/grx.rb

@@ -41,11 +41,12 @@ module GRX
     n = shape.reduce(1, :*)
     data = []
     (n / 2.0).ceil.times do
-      u1 = ::Kernel.rand; u1 = ::Kernel.rand while u1 < 1e-15
+      u1 = ::Kernel.rand
+      u1 = ::Kernel.rand while u1 < 1e-15
       u2 = ::Kernel.rand
       r  = Math.sqrt(-2.0 * Math.log(u1))
-      data << r * Math.cos(2 * Math::PI * u2)
-      data << r * Math.sin(2 * Math::PI * u2)
+      data << (r * Math.cos(2 * Math::PI * u2))
+      data << (r * Math.sin(2 * Math::PI * u2))
     end
     Tensor.create(data.first(n), shape, requires_grad: requires_grad)
   end
@@ -57,4 +58,8 @@ module GRX
   def self.mode
     CAPI::LOADED ? :c : :ruby
   end
+
+  def self.simd_mode
+    CAPI.simd_mode
+  end
 end