grx-tensor 0.1.0 → 0.2.0

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
@@ -291,11 +346,11 @@ module GRX
     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 +359,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 +378,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 +387,7 @@ module GRX
     end
 
     # ----------------------------------------------------------------
-    # ACTIVACIONES (con autograd)
+    # ACTIVATIONS (with autograd)
     # ----------------------------------------------------------------
 
     def relu
@@ -388,10 +443,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 +495,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 +512,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 +531,37 @@ module GRX
     end
 
     # ----------------------------------------------------------------
-    # GEOMETRÍA (zero-copy)
+    # GEOMETRY (zero-copy)
     # ----------------------------------------------------------------
 
     def get(*coords)
       @storage.read(_calc_flat_index(coords))
     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 +569,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,7 +607,7 @@ module GRX
     end
 
     # ----------------------------------------------------------------
-    # UTILIDADES
+    # UTILITIES
     # ----------------------------------------------------------------
 
     def numel
@@ -512,8 +615,8 @@ module GRX
     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 +624,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 +645,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 +707,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

data/lib/grx/utils.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module GRX
+  module Utils
+    # ================================================================
+    # clip_grad_norm! — Clips gradients of parameter collection so their
+    # combined L2 norm does not exceed max_norm.
+    # Prevents exploding gradient problems during deep network training.
+    # ================================================================
+    def self.clip_grad_norm!(parameters, max_norm)
+      max_norm = max_norm.to_f
+      total_norm_sq = 0.0
+      parameters.each do |p|
+        next unless p.grad
+        total_norm_sq += p.grad.square.to_a.sum
+      end
+      total_norm = Math.sqrt(total_norm_sq)
+      clip_coef = max_norm / (total_norm + 1e-6)
+      if clip_coef < 1.0
+        parameters.each do |p|
+          next unless p.grad
+          p.grad = p.grad.scale(clip_coef)
+        end
+      end
+      total_norm
+    end
+  end
+end

data/lib/grx/version.rb

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

data/lib/grx.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # =====================================================================
-# GRX — Framework de tensores con autograd y núcleo C+SIMD
+# GRX — Tensor framework with autograd and C+SIMD compute core
 # require "grx"
 # =====================================================================
 
@@ -10,12 +10,15 @@ require_relative "grx/errors"
 require_relative "grx/c_api"
 require_relative "grx/storage"
 require_relative "grx/tensor"
+require_relative "grx/serialization"
 require_relative "grx/nn"
 require_relative "grx/optim"
 require_relative "grx/loss"
+require_relative "grx/data"
+require_relative "grx/utils"
 
 module GRX
-  # Acceso rápido
+  # Quick factory helpers
   def self.tensor(data, shape, requires_grad: false)
     Tensor.create(data, shape, requires_grad: requires_grad)
   end
@@ -34,7 +37,7 @@ module GRX
   end
 
   def self.randn(shape, requires_grad: false)
-    # Box-Muller desde Ruby (el C lo hace más rápido vía he_normal)
+    # Box-Muller from Ruby (C backend executes faster via he_normal)
     n = shape.reduce(1, :*)
     data = []
     (n / 2.0).ceil.times do
@@ -46,4 +49,12 @@ module GRX
     end
     Tensor.create(data.first(n), shape, requires_grad: requires_grad)
   end
+
+  def self.c_loaded?
+    CAPI::LOADED
+  end
+
+  def self.mode
+    CAPI::LOADED ? :c : :ruby
+  end
 end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification
 name: grx-tensor
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
-- Angel Gabriel Garcia Razo
+- Razo
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
@@ -81,7 +81,9 @@ extensions:
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
+- GUIA_PRINCIPIANTES.md
 - LICENSE.txt
+- README.es.md
 - README.md
 - ext/grx/extconf.rb
 - ext/grx/grx_core.c
@@ -91,12 +93,15 @@ files:
 - grx-tensor.gemspec
 - lib/grx.rb
 - lib/grx/c_api.rb
+- lib/grx/data.rb
 - lib/grx/errors.rb
 - lib/grx/loss.rb
 - lib/grx/nn.rb
 - lib/grx/optim.rb
+- lib/grx/serialization.rb
 - lib/grx/storage.rb
 - lib/grx/tensor.rb
+- lib/grx/utils.rb
 - lib/grx/version.rb
 homepage: https://github.com/Gabo-Razo/grx-tensor
 licenses:
@@ -108,7 +113,7 @@ metadata:
 post_install_message: |2+
 
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    GRX-Tensor 0.1.0 installed
+    GRX-Tensor 0.2.0 installed
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   Compile the C extension to enable AVX2+FMA SIMD: