grx-tensor 0.1.0 → 0.2.1

data/lib/grx/storage.rb

@@ -4,46 +4,39 @@ require "fiddle"
 
 module GRX
   # ===================================================================
-  # Storage — Buffer de memoria nativa
+  # Storage — Native memory buffer
   #
-  # Cuando CAPI está cargado:
-  #   @ptr  → Fiddle::Pointer a un bloque de doubles alineado a 32 bytes
-  #           reservado con grx_alloc() (malloc alineado en C).
-  #           Los datos viven en el heap de C, NO en el GC de Ruby.
+  # When CAPI is loaded:
+  #   @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.
   #
-  # Cuando CAPI NO está cargado (fallback):
-  #   @data → Array de Ruby normal (lento pero siempre correcto).
-  #
-  # La separación entre los dos modos es transparente para Tensor.
+  # When CAPI is NOT loaded (fallback):
+  #   @data -> Standard Ruby Array (slow but correct).
   # ===================================================================
   class Storage
     attr_reader :size
-
-    # ptr expuesto para que CAPI pueda leerlo directamente
     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
-        # --- MODO RÁPIDO: memoria C alineada ---
-        # grx_alloc devuelve un double* alineado a 32 bytes
+        # Fast mode: aligned C memory
         @ptr = CAPI.grx_alloc(@size)
-        raise StorageError, "grx_alloc falló (OOM)" if @ptr.null?
+        raise StorageError, "grx_alloc failed (OOM)" if @ptr.null?
 
-        # Empaquetamos el Array de Ruby en el buffer C como doubles (little-endian)
-        # Array#pack("d*") → String binaria de IEEE 754 doubles
-        bytes = array_plano.pack("d*")
+        # Pack Ruby Array into C buffer as IEEE 754 doubles
+        bytes = flat.map(&:to_f).pack("d*")
         @ptr[0, bytes.bytesize] = bytes
 
-        # Registramos un finalizer para liberar la memoria C cuando el objeto
-        # Ruby sea recolectado por el GC. Usamos ObjectSpace para evitar
-        # que el closure capture self (lo que impediría la recolección).
+        # Finalizer releases C memory upon Ruby GC collection
         ptr_to_free = @ptr
         ObjectSpace.define_finalizer(self, self.class.make_finalizer(ptr_to_free))
       else
-        # --- MODO FALLBACK: Array de Ruby ---
-        @data = array_plano.map(&:to_f)
+        # Fallback mode: Ruby Array
+        @data = flat.map(&:to_f)
         @ptr  = nil
       end
     end
@@ -53,12 +46,11 @@ module GRX
     end
 
     # ------------------------------------------------------------------
-    # Lectura / escritura — usadas solo en modo fallback y por get()
-    # Las operaciones masivas (add, mul, etc.) van directo por @ptr en C.
+    # Read / Write — used in fallback mode and by item/get()
+    # High-performance tensor ops operate directly on @ptr in C.
     # ------------------------------------------------------------------
     def read(indice)
       if CAPI::LOADED
-        # Leemos 8 bytes desde el offset correcto y los desempaquetamos como double
         @ptr[indice * 8, 8].unpack1("d")
       else
         @data[indice]
@@ -73,7 +65,7 @@ module GRX
       end
     end
 
-    # Vuelca todo el buffer a un Array de Ruby (para to_a, inspect, tests)
+    # Dumps entire buffer to a Ruby Array
     def to_ruby_array
       if CAPI::LOADED
         @ptr[0, @size * 8].unpack("d#{@size}")

data/lib/grx/tensor.rb

@@ -40,7 +40,7 @@ module GRX
       ones(t.shape, requires_grad: requires_grad)
     end
 
-    # Inicialización Xavier uniform (para capas lineales con tanh/sigmoid)
+    # Xavier uniform initialization (optimal for linear layers with tanh/sigmoid)
     def self.xavier_uniform(shape, requires_grad: false)
       fan_in, fan_out = shape[-2] || 1, shape[-1] || 1
       n = shape.reduce(1, :*)
@@ -49,9 +49,9 @@ module GRX
       new(s, shape, requires_grad: requires_grad)
     end
 
-    # Inicialización He normal (para capas con ReLU)
+    # He normal initialization (optimal for layers with ReLU)
     def self.he_normal(shape, requires_grad: false)
-      # fan_in = número de entradas = último dim o penúltimo si es 2D
+      # fan_in = number of inputs = last dim or penultimate if 2D
       fan_in = shape.size >= 2 ? shape[-1] : shape[0]
       n = shape.reduce(1, :*)
       s = _alloc_raw(n)
@@ -60,13 +60,13 @@ module GRX
     end
 
     # ----------------------------------------------------------------
-    # OPERACIONES ARITMÉTICAS (con autograd)
+    # ARITHMETIC OPERATIONS (with autograd)
     # ----------------------------------------------------------------
 
     def +(other)
       case other
       when Tensor
-        raise ShapeError, "Shapes incompatibles: #{@shape} vs #{other.shape}" if @shape != other.shape
+        raise ShapeError, "Incompatible shapes: #{@shape} vs #{other.shape}" if @shape != other.shape
         r = Tensor.new(_binop(:grx_add, other), @shape)
         if requires_grad || other.requires_grad
           r.requires_grad = true
@@ -80,14 +80,14 @@ module GRX
       when Numeric
         add_scalar(other.to_f)
       else
-        raise TypeError, "No se puede sumar Tensor con #{other.class}"
+        raise TypeError, "Cannot add Tensor with #{other.class}"
       end
     end
 
     def -(other)
       case other
       when Tensor
-        raise ShapeError, "Shapes incompatibles: #{@shape} vs #{other.shape}" if @shape != other.shape
+        raise ShapeError, "Incompatible shapes: #{@shape} vs #{other.shape}" if @shape != other.shape
         r = Tensor.new(_binop(:grx_sub, other), @shape)
         if requires_grad || other.requires_grad
           r.requires_grad = true
@@ -101,14 +101,14 @@ module GRX
       when Numeric
         add_scalar(-other.to_f)
       else
-        raise TypeError, "No se puede restar Tensor con #{other.class}"
+        raise TypeError, "Cannot subtract Tensor with #{other.class}"
       end
     end
 
     def *(other)
       case other
       when Tensor
-        raise ShapeError, "Shapes incompatibles: #{@shape} vs #{other.shape}" if @shape != other.shape
+        raise ShapeError, "Incompatible shapes: #{@shape} vs #{other.shape}" if @shape != other.shape
         r = Tensor.new(_binop(:grx_mul, other), @shape)
         if requires_grad || other.requires_grad
           r.requires_grad = true
@@ -123,14 +123,14 @@ module GRX
       when Numeric
         scale(other.to_f)
       else
-        raise TypeError, "No se puede multiplicar Tensor con #{other.class}"
+        raise TypeError, "Cannot multiply Tensor with #{other.class}"
       end
     end
 
     def /(other)
       case other
       when Tensor
-        raise ShapeError, "Shapes incompatibles: #{@shape} vs #{other.shape}" if @shape != other.shape
+        raise ShapeError, "Incompatible shapes: #{@shape} vs #{other.shape}" if @shape != other.shape
         r = Tensor.new(_binop(:grx_div, other), @shape)
         if requires_grad || other.requires_grad
           r.requires_grad = true
@@ -146,7 +146,7 @@ module GRX
       when Numeric
         scale(1.0 / other.to_f)
       else
-        raise TypeError, "No se puede dividir Tensor con #{other.class}"
+        raise TypeError, "Cannot divide Tensor with #{other.class}"
       end
     end
 
@@ -155,23 +155,51 @@ module GRX
     end
 
     # ----------------------------------------------------------------
-    # OPERACIONES ESCALARES
+    # SCALAR OPERATIONS
     # ----------------------------------------------------------------
 
+    def coerce(other)
+      case other
+      when Numeric
+        # Returns reversed [self, other] wrapper to enable 2.0 * tensor
+        [Tensor.new(Storage.new(Array.new(numel, other.to_f)), @shape), self]
+      else
+        raise TypeError, "#{self.class} cannot be coerced with #{other.class}"
+      end
+    end
+
     def scale(s)
-      _unary_c(:grx_scale, s) { |v| v * s }
+      r = _unary_c(:grx_scale, s) { |v| v * s }
+      if requires_grad
+        r.requires_grad = true; r._grafo_hijos << self
+        src = self; factor = s.to_f
+        r.backward_fn = ->(g) { src.agregar_gradiente(g.scale(factor)) }
+      end
+      r
     end
 
     def add_scalar(s)
-      _unary_c(:grx_add_scalar, s) { |v| v + s }
+      r = _unary_c(:grx_add_scalar, s) { |v| v + s }
+      if requires_grad
+        r.requires_grad = true; r._grafo_hijos << self
+        src = self
+        r.backward_fn = ->(g) { src.agregar_gradiente(g) }
+      end
+      r
     end
 
     def negate
-      _unary_c(:grx_negate) { |v| -v }
+      r = _unary_c(:grx_negate) { |v| -v }
+      if requires_grad
+        r.requires_grad = true; r._grafo_hijos << self
+        src = self
+        r.backward_fn = ->(g) { src.agregar_gradiente(g.negate) }
+      end
+      r
     end
 
     # ----------------------------------------------------------------
-    # MATEMÁTICAS ELEMENT-WISE (con autograd)
+    # ELEMENT-WISE MATH (with autograd)
     # ----------------------------------------------------------------
 
     def abs
@@ -249,29 +277,56 @@ module GRX
         CAPI.grx_clip(@storage.ptr, lo.to_f, hi.to_f, out.ptr, numel)
       else
         data = to_a.map { |v| v < lo ? lo : (v > hi ? hi : v) }
-        return Tensor.create(data, @shape)
+        return Tensor.create(data, @shape, requires_grad: @requires_grad)
       end
-      Tensor.new(out, @shape)
+      r = Tensor.new(out, @shape)
+      if @requires_grad
+        r.requires_grad = true; r._grafo_hijos << self
+        src = self; l = lo.to_f; h = hi.to_f
+        r.backward_fn = ->(g) {
+          mask = Tensor.create(src.to_a.map { |v| (v >= l && v <= h) ? 1.0 : 0.0 }, src.shape)
+          src.agregar_gradiente(g * mask)
+        }
+      end
+      r
     end
 
     # ----------------------------------------------------------------
-    # REDUCCIONES (retornan Float o Tensor escalar)
+    # REDUCTIONS (return differentiable scalar Tensor with autograd)
     # ----------------------------------------------------------------
 
     def sum
-      if CAPI::LOADED
+      val = if CAPI::LOADED
         CAPI.grx_sum(@storage.ptr, numel)
       else
         to_a.sum
       end
+      r = Tensor.create([val], [1], requires_grad: @requires_grad)
+      if @requires_grad
+        r._grafo_hijos << self
+        src = self
+        r.backward_fn = ->(g) {
+          src.agregar_gradiente(Tensor.create(Array.new(src.numel, g.item), src.shape))
+        }
+      end
+      r
     end
 
     def mean
-      if CAPI::LOADED
+      val = if CAPI::LOADED
         CAPI.grx_mean(@storage.ptr, numel)
       else
         to_a.sum.to_f / numel
       end
+      r = Tensor.create([val], [1], requires_grad: @requires_grad)
+      if @requires_grad
+        r._grafo_hijos << self
+        src = self; n = numel.to_f
+        r.backward_fn = ->(g) {
+          src.agregar_gradiente(Tensor.create(Array.new(src.numel, g.item / n), src.shape))
+        }
+      end
+      r
     end
 
     def max
@@ -290,12 +345,40 @@ 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
+
     # ----------------------------------------------------------------
-    # ÁLGEBRA LINEAL
+    # LINEAR ALGEBRA
     # ----------------------------------------------------------------
 
     def dot(other)
-      raise ShapeError, "dot requiere mismo shape" if @shape != other.shape
+      raise ShapeError, "dot requires matching shape" if @shape != other.shape
       if CAPI::LOADED
         CAPI.grx_dot(@storage.ptr, other.storage.ptr, numel)
       else
@@ -304,9 +387,9 @@ module GRX
     end
 
     def matmul(other)
-      raise DimensionError, "matmul requiere tensores 2D" unless @shape.size == 2 && other.shape.size == 2
+      raise DimensionError, "matmul requires 2D tensors" unless @shape.size == 2 && other.shape.size == 2
       m, k = @shape; k2, n = other.shape
-      raise ShapeError, "Dimensiones incompatibles: #{@shape} × #{other.shape}" if k != k2
+      raise ShapeError, "Incompatible dimensions: #{@shape} × #{other.shape}" if k != k2
       out = _alloc_storage(m * n)
       if CAPI::LOADED
         CAPI.grx_matmul(@storage.ptr, other.storage.ptr, out.ptr, m, k, n)
@@ -323,7 +406,7 @@ module GRX
         r._grafo_hijos.push(a, b)
         r.backward_fn = ->(g) {
           # dL/dA = dL/dC × B^T,  dL/dB = A^T × dL/dC
-          # Usamos _matmul_no_grad y _transpose_view para no crear nodos en el grafo
+          # Uses _matmul_no_grad and _transpose_view to avoid graph recursion
           a.agregar_gradiente(g._matmul_no_grad(b._transpose_view)) if a.requires_grad
           b.agregar_gradiente(a._transpose_view._matmul_no_grad(g)) if b.requires_grad
         }
@@ -332,7 +415,7 @@ module GRX
     end
 
     # ----------------------------------------------------------------
-    # ACTIVACIONES (con autograd)
+    # ACTIVATIONS (with autograd)
     # ----------------------------------------------------------------
 
     def relu
@@ -388,10 +471,39 @@ module GRX
     end
 
     def softmax
-      r = _unary_c(:grx_softmax) do
-        vals = to_a; max_v = vals.max
-        exps = vals.map { |v| Math.exp(v - max_v) }; s = exps.sum
-        exps.map { |e| e / s }
+      dim = @shape[-1]
+      batch = numel / dim
+      raw = to_a
+      out_vals = Array.new(numel)
+
+      batch.times do |b|
+        slice = raw.slice(b * dim, dim)
+        max_v = slice.max
+        exps = slice.map { |v| Math.exp(v - max_v) }
+        sum_e = exps.sum
+        dim.times { |j| out_vals[b * dim + j] = exps[j] / sum_e }
+      end
+
+      r = Tensor.create(out_vals, @shape, requires_grad: @requires_grad)
+      if @requires_grad
+        r._grafo_hijos << self
+        res = r; src = self
+        r.backward_fn = ->(g) {
+          s_data = res.to_a
+          g_data = g.to_a
+          grad_x = Array.new(src.numel, 0.0)
+
+          batch.times do |b|
+            s_row = s_data.slice(b * dim, dim)
+            g_row = g_data.slice(b * dim, dim)
+            dot = s_row.zip(g_row).sum { |s_val, g_val| s_val * g_val }
+            dim.times do |j|
+              grad_x[b * dim + j] = s_row[j] * (g_row[j] - dot)
+            end
+          end
+
+          src.agregar_gradiente(Tensor.create(grad_x, src.shape))
+        }
       end
       r
     end
@@ -411,7 +523,7 @@ module GRX
         agregar_gradiente(grad_inicial)
       end
 
-      # Orden topológico via DFS iterativo post-order (evita stack overflow en grafos profundos)
+      # Topological sorting via iterative post-order DFS (prevents stack overflow on deep graphs)
       orden     = []
       visitados = {}
       stack     = [[self, false]]
@@ -428,7 +540,7 @@ module GRX
         end
       end
 
-      # orden ya está en post-order → reverse = raíz primero, hojas al final
+      # Topological order in post-order: reverse traverses root first down to leaves
       orden.reverse_each do |nodo|
         next unless nodo.grad && nodo.backward_fn
         nodo.backward_fn.call(nodo.grad)
@@ -447,20 +559,41 @@ module GRX
     end
 
     # ----------------------------------------------------------------
-    # GEOMETRÍA (zero-copy)
+    # GEOMETRY (zero-copy)
     # ----------------------------------------------------------------
 
     def get(*coords)
       @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)
+      if @requires_grad
+        c._grafo_hijos << self
+        src = self
+        c.backward_fn = ->(g) { src.agregar_gradiente(g) }
+      end
+      c
+    end
+
     def reshape(nueva_forma)
-      raise ArgumentError, "Reshape incompatible" if numel != nueva_forma.reduce(1,:*)
-      Tensor.new(@storage, nueva_forma, offset: @offset, requires_grad: @requires_grad)
+      raise ArgumentError, "Incompatible reshape" if numel != nueva_forma.reduce(1,:*)
+      r = Tensor.new(@storage, nueva_forma, offset: @offset, requires_grad: @requires_grad)
+      if @requires_grad
+        r._grafo_hijos << self
+        src = self; orig_shape = @shape
+        r.backward_fn = ->(g) { src.agregar_gradiente(g.reshape(orig_shape)) }
+      end
+      r
     end
 
     def transpose
-      raise DimensionError, "transpose solo soporta 2D" if @shape.size != 2
+      raise DimensionError, "transpose only supports 2D tensors" if @shape.size != 2
       t = Tensor.new(@storage, [@shape[1], @shape[0]],
                  strides: [@strides[1], @strides[0]],
                  offset: @offset, requires_grad: @requires_grad)
@@ -468,32 +601,34 @@ module GRX
         t._grafo_hijos << self
         src = self
         t.backward_fn = ->(g) {
-          src.agregar_gradiente(g._transpose_view)
+          src.agregar_gradiente(g.transpose)
         }
       end
       t
     end
 
-    # Transpose sin autograd — solo para uso interno en backward
+    # Transpose view without autograd — for internal backward pass
     def _transpose_view
-      raise DimensionError, "transpose solo soporta 2D" if @shape.size != 2
+      raise DimensionError, "transpose only supports 2D tensors" if @shape.size != 2
       Tensor.new(@storage, [@shape[1], @shape[0]],
                  strides: [@strides[1], @strides[0]],
                  offset: @offset, requires_grad: false)
     end
 
-    # Matmul sin autograd — para uso interno en backward_fn
+    # Matmul without autograd — for internal backward_fn usage
     def _matmul_no_grad(other)
-      raise DimensionError, "matmul requiere tensores 2D" unless @shape.size == 2 && other.shape.size == 2
+      raise DimensionError, "matmul requires 2D tensors" unless @shape.size == 2 && other.shape.size == 2
       m, k = @shape; k2, n = other.shape
-      raise ShapeError, "Dimensiones incompatibles" if k != k2
+      raise ShapeError, "Incompatible dimensions" if k != k2
+      a_c = _contiguous? ? self : contiguous
+      b_c = other._contiguous? ? other : other.contiguous
       out = _alloc_storage(m * n)
       if CAPI::LOADED
-        CAPI.grx_matmul(@storage.ptr, other.storage.ptr, out.ptr, m, k, n)
+        CAPI.grx_matmul(a_c.storage.ptr, b_c.storage.ptr, out.ptr, m, k, n)
       else
         result = Array.new(m * n, 0.0)
-        m.times { |i| k.times { |kk| aik = @storage.read(i*k+kk)
-          n.times { |j| result[i*n+j] += aik * other.storage.read(kk*n+j) } } }
+        m.times { |i| k.times { |kk| aik = a_c.storage.read(i*k+kk)
+          n.times { |j| result[i*n+j] += aik * b_c.storage.read(kk*n+j) } } }
         return Tensor.new(Storage.new(result), [m, n])
       end
       Tensor.new(out, [m, n])
@@ -504,16 +639,20 @@ module GRX
     end
 
     # ----------------------------------------------------------------
-    # UTILIDADES
+    # UTILITIES
     # ----------------------------------------------------------------
 
     def numel
       @shape.reduce(1, :*)
     end
 
+    def rank
+      @shape.size
+    end
+
     def to_a
-      # Si los strides son contiguos (tensor normal, reshape), leemos el buffer directo.
-      # Si no (transpose, vistas con strides custom), recorremos con strides.
+      # If strides are contiguous (normal tensor, reshape), read buffer directly.
+      # Otherwise (transpose, strided views), traverse with custom strides.
       if _contiguous?
         @storage.to_ruby_array
       else
@@ -521,13 +660,14 @@ module GRX
       end
     end
 
-    private
-
-    # Un tensor es contiguo si sus strides coinciden con los strides row-major estándar
-    def _contiguous?
+    # A tensor is contiguous if its strides match standard row-major order
+    def contiguous?
       expected = _calc_strides(@shape)
       @strides == expected && @offset == 0
     end
+    alias _contiguous? contiguous?
+
+    private
 
     def _collect_elements(shape, strides, offset)
       if shape.size == 1
@@ -541,18 +681,46 @@ module GRX
 
     public
 
+    include Comparable
+
+    def <=>(other)
+      case other
+      when Tensor
+        (numel == 1 && other.numel == 1) ? item <=> other.item : nil
+      when Numeric
+        numel == 1 ? item <=> other.to_f : nil
+      else
+        nil
+      end
+    end
+
     def item
-      raise "item() solo para tensores de 1 elemento" if numel != 1
+      raise "item() only supported for 1-element tensors" if numel != 1
       to_a[0]
     end
 
+    def to_f
+      raise "to_f only supported for 1-element tensors" if numel != 1
+      to_a[0]
+    end
+
+    def to_i
+      raise "to_i only supported for 1-element tensors" if numel != 1
+      to_a[0].to_i
+    end
+
+    def nan?
+      raise "nan? only supported for 1-element tensors" if numel != 1
+      to_a[0].nan?
+    end
+
     def to_s
       "#<GRX::Tensor shape=#{@shape} data=#{to_a}>"
     end
     alias inspect to_s
 
     # ----------------------------------------------------------------
-    # PRIVADO
+    # PRIVATE
     # ----------------------------------------------------------------
 
     private
@@ -575,33 +743,34 @@ module GRX
       end
     end
 
-    # Operación binaria element-wise: llama a CAPI o fallback Ruby
+    # Element-wise binary op: delegates to CAPI or Ruby fallback
     def _binop(op, other)
+      a_c = _contiguous? ? self : contiguous
+      b_c = other._contiguous? ? other : other.contiguous
       out = _alloc_storage(numel)
       if CAPI::LOADED
-        CAPI.public_send(op, @storage.ptr, other.storage.ptr, out.ptr, numel)
+        CAPI.public_send(op, a_c.storage.ptr, b_c.storage.ptr, out.ptr, numel)
       else
         rb = { grx_add: :+, grx_sub: :-, grx_mul: :*, grx_div: :/ }[op]
         data = (0...numel).map { |i|
-          @storage.read(@offset + i).public_send(rb, other.storage.read(other.offset + i))
+          a_c.storage.read(a_c.offset + i).public_send(rb, b_c.storage.read(b_c.offset + i))
         }
         return Storage.new(data)
       end
       out
     end
 
-    # Operación unaria: llama a CAPI con args opcionales o fallback con bloque
-    # Si el bloque acepta un elemento (arity == 1) → map element-wise
-    # Si el bloque no acepta argumentos (arity == 0) → lo llama una vez (para softmax, etc.)
+    # Unary op: delegates to CAPI with optional args or Ruby fallback block
     def _unary_c(op, *args, &fallback)
+      a_c = _contiguous? ? self : contiguous
       out = _alloc_storage(numel)
       if CAPI::LOADED
-        CAPI.public_send(op, @storage.ptr, *args, out.ptr, numel)
+        CAPI.public_send(op, a_c.storage.ptr, *args, out.ptr, numel)
       else
         vals = if fallback
-          fallback.arity == 0 ? fallback.call : to_a.map(&fallback)
+          fallback.arity == 0 ? fallback.call : a_c.to_a.map(&fallback)
         else
-          to_a
+          a_c.to_a
         end
         return Tensor.create(vals, @shape)
       end