grnexus 1.0.2

data/lib/grnexus_numeric_proccessing.rb

@@ -0,0 +1,722 @@
+require 'ffi'
+require 'rbconfig'
+
+module GRNEXUSNumericProcessing
+  extend FFI::Library
+
+  # Detectar sistema operativo
+  def self.detect_library
+    script_dir = File.dirname(File.expand_path(__FILE__))
+    os = RbConfig::CONFIG['host_os']
+
+    case os
+    when /mswin|mingw|cygwin/
+      File.join(script_dir, '..', 'exports', 'Windows', 'numeric_proccessing.dll')
+    when /darwin/
+      File.join(script_dir, '..', 'exports', 'Mac', 'numeric_proccessing.dylib')
+    when /linux/
+      File.join(script_dir, '..', 'exports', 'Linux', 'numeric_proccessing.so')
+    else
+      raise "Sistema operativo no soportado: #{os}"
+    end
+  end
+
+  # Cargar biblioteca
+  ffi_lib detect_library
+
+  # Definir estructura GRNexusData
+  class GRNexusData < FFI::Struct
+    layout :data,   :pointer,
+           :type,   :int,
+           :size,   :size_t,
+           :stride, :size_t,
+           :dims,   [:size_t, 3]
+  end
+
+  # Definir funciones disponibles basadas en numeric_proccessing.c
+  FUNCTIONS = {
+    # Operaciones binarias entre arrays
+    'SumArray' => [:SumArray, [:pointer, :pointer, :pointer, :bool], :int],
+    'ProductArray' => [:ProductArray, [:pointer, :pointer, :pointer, :bool], :int],
+    'SubtractArray' => [:SubtractArray, [:pointer, :pointer, :pointer, :bool], :int],
+    'DivideArray' => [:DivideArray, [:pointer, :pointer, :pointer, :bool], :int],
+    'PowerArray' => [:PowerArray, [:pointer, :pointer, :pointer, :bool], :int],
+    'ModuloArray' => [:ModuloArray, [:pointer, :pointer, :pointer, :bool], :int],
+    'MaxArray' => [:MaxArray, [:pointer, :pointer, :pointer, :bool], :int],
+    'MinArray' => [:MinArray, [:pointer, :pointer, :pointer, :bool], :int],
+    
+    # Operaciones con escalar
+    'AddScalarToArray' => [:AddScalarToArray, [:pointer, :double, :pointer, :bool], :int],
+    'MultiplyScalarToArray' => [:MultiplyScalarToArray, [:pointer, :double, :pointer, :bool], :int],
+    
+    # Operaciones estadísticas (retornan escalar)
+    'MeanArray' => [:MeanArray, [:pointer, :pointer, :bool], :int],
+    'VarianceArray' => [:VarianceArray, [:pointer, :pointer, :bool], :int],
+    'StdArray' => [:StdArray, [:pointer, :pointer, :bool], :int],
+    'MaxValueArray' => [:MaxValueArray, [:pointer, :pointer, :bool], :int],
+    'MinValueArray' => [:MinValueArray, [:pointer, :pointer, :bool], :int],
+    'SumAllArray' => [:SumAllArray, [:pointer, :pointer, :bool], :int],
+    'ProductAllArray' => [:ProductAllArray, [:pointer, :pointer, :bool], :int],
+    
+    # Operaciones de arrays
+    'ConcatenateArrays' => [:ConcatenateArrays, [:pointer, :pointer, :pointer, :bool], :int],
+    'MovingAverage' => [:MovingAverage, [:pointer, :pointer, :bool, :size_t], :int],
+    'FiniteDifference' => [:FiniteDifference, [:pointer, :pointer, :bool], :int],
+    'DiscreteIntegral' => [:DiscreteIntegral, [:pointer, :pointer, :bool], :int],
+    'ZScoreNormalize' => [:ZScoreNormalize, [:pointer, :pointer, :bool], :int],
+    'MinMaxNormalize' => [:MinMaxNormalize, [:pointer, :pointer, :bool, :double, :double], :int],
+    
+    # Funciones de activación numéricas
+    'LinearNum' => [:LinearNum, [:pointer, :pointer, :bool], :int],
+    'ReLUNum' => [:ReLUNum, [:pointer, :pointer, :bool], :int],
+    'SigmoidNum' => [:SigmoidNum, [:pointer, :pointer, :bool], :int],
+    'TanhNum' => [:TanhNum, [:pointer, :pointer, :bool], :int],
+    'LeakyReLUNum' => [:LeakyReLUNum, [:pointer, :pointer, :bool, :double], :int],
+    'ELUNum' => [:ELUNum, [:pointer, :pointer, :bool, :double], :int],
+    'SoftplusNum' => [:SoftplusNum, [:pointer, :pointer, :bool], :int],
+    'GELUNum' => [:GELUNum, [:pointer, :pointer, :bool], :int],
+    'SwishNum' => [:SwishNum, [:pointer, :pointer, :bool], :int],
+    'MishNum' => [:MishNum, [:pointer, :pointer, :bool], :int],
+    'SiLUNum' => [:SiLUNum, [:pointer, :pointer, :bool], :int],
+    'HardTanhNum' => [:HardTanhNum, [:pointer, :pointer, :bool], :int],
+    'HardSigmoidNum' => [:HardSigmoidNum, [:pointer, :pointer, :bool], :int],
+    'HardSwishNum' => [:HardSwishNum, [:pointer, :pointer, :bool], :int],
+    'SoftsignNum' => [:SoftsignNum, [:pointer, :pointer, :bool], :int],
+    'SELUNum' => [:SELUNum, [:pointer, :pointer, :bool], :int],
+    'CELUNum' => [:CELUNum, [:pointer, :pointer, :bool, :double], :int],
+    'ISRUNum' => [:ISRUNum, [:pointer, :pointer, :bool, :double], :int],
+    'ISRLUNum' => [:ISRLUNum, [:pointer, :pointer, :bool, :double], :int],
+    'ReLU6Num' => [:ReLU6Num, [:pointer, :pointer, :bool], :int],
+    'ThresholdedReLUNum' => [:ThresholdedReLUNum, [:pointer, :pointer, :bool, :double], :int],
+    'PReLUNum' => [:PReLUNum, [:pointer, :pointer, :bool, :pointer], :int],
+    'SquaredReLUNum' => [:SquaredReLUNum, [:pointer, :pointer, :bool], :int],
+    'LiSHTNum' => [:LiSHTNum, [:pointer, :pointer, :bool], :int],
+    'SnakeNum' => [:SnakeNum, [:pointer, :pointer, :bool, :double], :int],
+    'SnakeBetaNum' => [:SnakeBetaNum, [:pointer, :pointer, :bool, :double, :double], :int],
+    'AReluNum' => [:AReluNum, [:pointer, :pointer, :bool, :double, :double], :int],
+    'FReLUNum' => [:FReLUNum, [:pointer, :pointer, :bool, :double], :int],
+    'BReLUNum' => [:BReLUNum, [:pointer, :pointer, :bool], :int],
+    'HardShrinkNum' => [:HardShrinkNum, [:pointer, :pointer, :bool, :double], :int],
+    'SoftShrinkNum' => [:SoftShrinkNum, [:pointer, :pointer, :bool, :double], :int],
+    'TanhShrinkNum' => [:TanhShrinkNum, [:pointer, :pointer, :bool], :int],
+    'MaxoutNum' => [:MaxoutNum, [:pointer, :pointer, :bool, :size_t], :int],
+    'MinoutNum' => [:MinoutNum, [:pointer, :pointer, :bool, :size_t], :int],
+    'GLUNum' => [:GLUNum, [:pointer, :pointer, :bool, :size_t], :int],
+    'ReLUSquaredNum' => [:ReLUSquaredNum, [:pointer, :pointer, :bool], :int],
+  }
+
+  # Adjuntar funciones al módulo
+  FUNCTIONS.each do |name, (func, args, ret)|
+    attach_function func, args, ret
+  end
+
+  # Función para crear GRNexusData
+  def self.create_grnexus_data(array_or_scalar)
+    # Convertir a array si es un número
+    values = array_or_scalar.is_a?(Array) ? array_or_scalar.flatten : [array_or_scalar]
+    size = values.length
+    
+    # Crear un buffer con los datos
+    buffer = FFI::MemoryPointer.new(:double, size)
+    buffer.write_array_of_double(values)
+    
+    data = FFI::MemoryPointer.new(GRNexusData.size)
+    struct_instance = GRNexusData.new(data)
+    struct_instance[:data] = buffer
+    struct_instance[:type] = size == 1 ? 0 : 1  # SCALAR=0, ARRAY=1
+    struct_instance[:size] = size
+    struct_instance[:stride] = 1
+    struct_instance[:dims][0] = size
+    struct_instance[:dims][1] = 0
+    struct_instance[:dims][2] = 0
+    
+    [data, buffer]
+  end
+
+  # Función para crear GRNexusData para salida
+  def self.create_output_grnexus_data(size)
+    # Crear un buffer vacío modificable
+    buffer = FFI::MemoryPointer.new(:double, size)
+    
+    data = FFI::MemoryPointer.new(GRNexusData.size)
+    struct_instance = GRNexusData.new(data)
+    struct_instance[:data] = buffer
+    struct_instance[:type] = 1  # ARRAY
+    struct_instance[:size] = size
+    struct_instance[:stride] = 1
+    struct_instance[:dims][0] = size
+    struct_instance[:dims][1] = 0
+    struct_instance[:dims][2] = 0
+    
+    [data, buffer]
+  end
+
+  # Función para leer datos de GRNexusData
+  def self.read_grnexus_data(original_ptr, size)
+    original_ptr.read_array_of_double(size)
+  end
+
+  # Clase base para procesadores numéricos
+  class NumericProcessor
+    def process(*args)
+      raise NotImplementedError, "Debes implementar el método de procesamiento numérico"
+    end
+  end
+
+  # Clase base para operaciones
+  class BaseNumericOperation < NumericProcessor
+    protected
+
+    def execute_binary_operation(func_name, input1, input2, derivative: false)
+      input1_data, input1_buffer = GRNEXUSNumericProcessing.create_grnexus_data(input1)
+      input2_data, input2_buffer = GRNEXUSNumericProcessing.create_grnexus_data(input2)
+      
+      input1_size = input1.is_a?(Array) ? input1.flatten.length : 1
+      input2_size = input2.is_a?(Array) ? input2.flatten.length : 1
+      
+      # Calcular tamaño de salida según la operación
+      output_size = if func_name == :ConcatenateArrays
+                      input1_size + input2_size
+                    else
+                      input1_size  # Mismo tamaño que input1 para operaciones elemento a elemento
+                    end
+      
+      output_data, output_buffer = GRNEXUSNumericProcessing.create_output_grnexus_data(output_size)
+
+      args = [input1_data, input2_data, output_data, derivative]
+      result = GRNEXUSNumericProcessing.send(func_name, *args)
+
+      if result == 0
+        output_buffer.read_array_of_double(output_size)
+      else
+        raise "Función #{func_name} falló con código: #{result}"
+      end
+    ensure
+      # FFI::MemoryPointer se libera automáticamente con GC
+    end
+
+    def execute_unary_operation(func_name, input, derivative: false, **kwargs)
+      input_data, input_buffer = GRNEXUSNumericProcessing.create_grnexus_data(input)
+      input_size = input.is_a?(Array) ? input.flatten.length : 1
+      
+      # Para operaciones que retornan escalar
+      scalar_output = ['MeanArray', 'VarianceArray', 'StdArray', 'MaxValueArray', 
+                       'MinValueArray', 'SumAllArray', 'ProductAllArray'].include?(func_name.to_s)
+      
+      # Calcular tamaño de salida
+      output_size = if scalar_output
+                      1
+                    elsif func_name == :MovingAverage
+                      window_size = kwargs[:window_size] || 3
+                      [input_size - window_size + 1, 0].max
+                    elsif func_name == :FiniteDifference
+                      [input_size - 1, 0].max
+                    else
+                      input_size
+                    end
+      
+      output_data, output_buffer = GRNEXUSNumericProcessing.create_output_grnexus_data(output_size)
+
+      args = [input_data, output_data, derivative]
+      
+      # Agregar argumentos adicionales según la función
+      case func_name
+      when :MovingAverage
+        args << (kwargs[:window_size] || 3)
+      when :MinMaxNormalize
+        args << (kwargs[:min_range] || 0.0) << (kwargs[:max_range] || 1.0)
+      when :LeakyReLUNum, :ELUNum, :CELUNum, :ISRUNum, :ISRLUNum, :ThresholdedReLUNum, 
+           :FReLUNum, :HardShrinkNum, :SoftShrinkNum, :SnakeNum
+        args << (kwargs[:param1] || 0.01)
+      when :SnakeBetaNum, :AReluNum
+        args << (kwargs[:param1] || 1.0) << (kwargs[:param2] || 1.0)
+      when :PReLUNum
+        alpha_ptr = FFI::MemoryPointer.new(:double)
+        alpha_ptr.write_double(kwargs[:param1] || 0.01)
+        args << alpha_ptr
+      when :MaxoutNum, :MinoutNum, :GLUNum
+        args << (kwargs[:num_pieces] || 2)
+      end
+
+      result = GRNEXUSNumericProcessing.send(func_name, *args)
+
+      if result == 0
+        result_array = output_buffer.read_array_of_double(output_size)
+        scalar_output ? result_array[0] : result_array
+      else
+        raise "Función #{func_name} falló con código: #{result}"
+      end
+    ensure
+      # FFI::MemoryPointer se libera automáticamente con GC
+    end
+
+    def execute_scalar_operation(func_name, input, scalar, derivative: false)
+      input_data, input_buffer = GRNEXUSNumericProcessing.create_grnexus_data(input)
+      input_size = input.is_a?(Array) ? input.flatten.length : 1
+      output_data, output_buffer = GRNEXUSNumericProcessing.create_output_grnexus_data(input_size)
+
+      args = [input_data, scalar, output_data, derivative]
+      result = GRNEXUSNumericProcessing.send(func_name, *args)
+
+      if result == 0
+        output_buffer.read_array_of_double(input_size)
+      else
+        raise "Función #{func_name} falló con código: #{result}"
+      end
+    ensure
+      # FFI::MemoryPointer se libera automáticamente con GC
+    end
+  end
+
+  # ============================================================================
+  # OPERACIONES BINARIAS ENTRE ARRAYS
+  # ============================================================================
+
+  class SumArray < BaseNumericOperation
+    def process(a, b, derivative: false)
+      execute_binary_operation(:SumArray, a, b, derivative: derivative)
+    end
+  end
+
+  class ProductArray < BaseNumericOperation
+    def process(a, b, derivative: false)
+      execute_binary_operation(:ProductArray, a, b, derivative: derivative)
+    end
+  end
+
+  class SubtractArray < BaseNumericOperation
+    def process(a, b, derivative: false)
+      execute_binary_operation(:SubtractArray, a, b, derivative: derivative)
+    end
+  end
+
+  class DivideArray < BaseNumericOperation
+    def process(a, b, derivative: false)
+      execute_binary_operation(:DivideArray, a, b, derivative: derivative)
+    end
+  end
+
+  class PowerArray < BaseNumericOperation
+    def process(a, b, derivative: false)
+      execute_binary_operation(:PowerArray, a, b, derivative: derivative)
+    end
+  end
+
+  class ModuloArray < BaseNumericOperation
+    def process(a, b, derivative: false)
+      execute_binary_operation(:ModuloArray, a, b, derivative: derivative)
+    end
+  end
+
+  class MaxArray < BaseNumericOperation
+    def process(a, b, derivative: false)
+      execute_binary_operation(:MaxArray, a, b, derivative: derivative)
+    end
+  end
+
+  class MinArray < BaseNumericOperation
+    def process(a, b, derivative: false)
+      execute_binary_operation(:MinArray, a, b, derivative: derivative)
+    end
+  end
+
+  # ============================================================================
+  # OPERACIONES CON ESCALAR
+  # ============================================================================
+
+  class AddScalarToArray < BaseNumericOperation
+    def process(a, scalar, derivative: false)
+      execute_scalar_operation(:AddScalarToArray, a, scalar, derivative: derivative)
+    end
+  end
+
+  class MultiplyScalarToArray < BaseNumericOperation
+    def process(a, scalar, derivative: false)
+      execute_scalar_operation(:MultiplyScalarToArray, a, scalar, derivative: derivative)
+    end
+  end
+
+  # ============================================================================
+  # OPERACIONES ESTADÍSTICAS (RETORNAN ESCALAR)
+  # ============================================================================
+
+  class MeanArray < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:MeanArray, a, derivative: derivative)
+    end
+  end
+
+  class VarianceArray < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:VarianceArray, a, derivative: derivative)
+    end
+  end
+
+  class StdArray < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:StdArray, a, derivative: derivative)
+    end
+  end
+
+  class MaxValueArray < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:MaxValueArray, a, derivative: derivative)
+    end
+  end
+
+  class MinValueArray < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:MinValueArray, a, derivative: derivative)
+    end
+  end
+
+  class SumAllArray < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:SumAllArray, a, derivative: derivative)
+    end
+  end
+
+  class ProductAllArray < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:ProductAllArray, a, derivative: derivative)
+    end
+  end
+
+  # ============================================================================
+  # OPERACIONES DE ARRAYS
+  # ============================================================================
+
+  class ConcatenateArrays < BaseNumericOperation
+    def process(a, b, derivative: false)
+      execute_binary_operation(:ConcatenateArrays, a, b, derivative: derivative)
+    end
+  end
+
+  class MovingAverage < BaseNumericOperation
+    def initialize(window_size: 3)
+      @window_size = window_size
+    end
+
+    def process(a, derivative: false)
+      execute_unary_operation(:MovingAverage, a, derivative: derivative, window_size: @window_size)
+    end
+  end
+
+  class FiniteDifference < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:FiniteDifference, a, derivative: derivative)
+    end
+  end
+
+  class DiscreteIntegral < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:DiscreteIntegral, a, derivative: derivative)
+    end
+  end
+
+  class ZScoreNormalize < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:ZScoreNormalize, a, derivative: derivative)
+    end
+  end
+
+  class MinMaxNormalize < BaseNumericOperation
+    def initialize(min_range: 0.0, max_range: 1.0)
+      @min_range = min_range
+      @max_range = max_range
+    end
+
+    def process(a, derivative: false)
+      execute_unary_operation(:MinMaxNormalize, a, derivative: derivative, 
+                             min_range: @min_range, max_range: @max_range)
+    end
+  end
+
+  # ============================================================================
+  # FUNCIONES DE ACTIVACIÓN NUMÉRICAS
+  # ============================================================================
+
+  class LinearNum < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:LinearNum, a, derivative: derivative)
+    end
+  end
+
+  class ReLUNum < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:ReLUNum, a, derivative: derivative)
+    end
+  end
+
+  class SigmoidNum < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:SigmoidNum, a, derivative: derivative)
+    end
+  end
+
+  class TanhNum < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:TanhNum, a, derivative: derivative)
+    end
+  end
+
+  class LeakyReLUNum < BaseNumericOperation
+    def initialize(alpha: 0.01)
+      @alpha = alpha
+    end
+
+    def process(a, derivative: false)
+      execute_unary_operation(:LeakyReLUNum, a, derivative: derivative, param1: @alpha)
+    end
+  end
+
+  class ELUNum < BaseNumericOperation
+    def initialize(alpha: 1.0)
+      @alpha = alpha
+    end
+
+    def process(a, derivative: false)
+      execute_unary_operation(:ELUNum, a, derivative: derivative, param1: @alpha)
+    end
+  end
+
+  class SoftplusNum < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:SoftplusNum, a, derivative: derivative)
+    end
+  end
+
+  class GELUNum < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:GELUNum, a, derivative: derivative)
+    end
+  end
+
+  class SwishNum < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:SwishNum, a, derivative: derivative)
+    end
+  end
+
+  class MishNum < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:MishNum, a, derivative: derivative)
+    end
+  end
+
+  class SiLUNum < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:SiLUNum, a, derivative: derivative)
+    end
+  end
+
+  class HardTanhNum < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:HardTanhNum, a, derivative: derivative)
+    end
+  end
+
+  class HardSigmoidNum < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:HardSigmoidNum, a, derivative: derivative)
+    end
+  end
+
+  class HardSwishNum < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:HardSwishNum, a, derivative: derivative)
+    end
+  end
+
+  class SoftsignNum < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:SoftsignNum, a, derivative: derivative)
+    end
+  end
+
+  class SELUNum < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:SELUNum, a, derivative: derivative)
+    end
+  end
+
+  class CELUNum < BaseNumericOperation
+    def initialize(alpha: 1.0)
+      @alpha = alpha
+    end
+
+    def process(a, derivative: false)
+      execute_unary_operation(:CELUNum, a, derivative: derivative, param1: @alpha)
+    end
+  end
+
+  class ISRUNum < BaseNumericOperation
+    def initialize(alpha: 1.0)
+      @alpha = alpha
+    end
+
+    def process(a, derivative: false)
+      execute_unary_operation(:ISRUNum, a, derivative: derivative, param1: @alpha)
+    end
+  end
+
+  class ISRLUNum < BaseNumericOperation
+    def initialize(alpha: 1.0)
+      @alpha = alpha
+    end
+
+    def process(a, derivative: false)
+      execute_unary_operation(:ISRLUNum, a, derivative: derivative, param1: @alpha)
+    end
+  end
+
+  class ReLU6Num < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:ReLU6Num, a, derivative: derivative)
+    end
+  end
+
+  class ThresholdedReLUNum < BaseNumericOperation
+    def initialize(theta: 1.0)
+      @theta = theta
+    end
+
+    def process(a, derivative: false)
+      execute_unary_operation(:ThresholdedReLUNum, a, derivative: derivative, param1: @theta)
+    end
+  end
+
+  class PReLUNum < BaseNumericOperation
+    def initialize(alpha: 0.01)
+      @alpha = alpha
+    end
+
+    def process(a, derivative: false)
+      execute_unary_operation(:PReLUNum, a, derivative: derivative, param1: @alpha)
+    end
+  end
+
+  class SquaredReLUNum < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:SquaredReLUNum, a, derivative: derivative)
+    end
+  end
+
+  class LiSHTNum < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:LiSHTNum, a, derivative: derivative)
+    end
+  end
+
+  class SnakeNum < BaseNumericOperation
+    def initialize(alpha: 1.0)
+      @alpha = alpha
+    end
+
+    def process(a, derivative: false)
+      execute_unary_operation(:SnakeNum, a, derivative: derivative, param1: @alpha)
+    end
+  end
+
+  class SnakeBetaNum < BaseNumericOperation
+    def initialize(alpha: 1.0, beta: 1.0)
+      @alpha = alpha
+      @beta = beta
+    end
+
+    def process(a, derivative: false)
+      execute_unary_operation(:SnakeBetaNum, a, derivative: derivative, 
+                             param1: @alpha, param2: @beta)
+    end
+  end
+
+  class AReluNum < BaseNumericOperation
+    def initialize(alpha: 0.0, beta: 1.0)
+      @alpha = alpha
+      @beta = beta
+    end
+
+    def process(a, derivative: false)
+      execute_unary_operation(:AReluNum, a, derivative: derivative, 
+                             param1: @alpha, param2: @beta)
+    end
+  end
+
+  class FReLUNum < BaseNumericOperation
+    def initialize(alpha: 1.0)
+      @alpha = alpha
+    end
+
+    def process(a, derivative: false)
+      execute_unary_operation(:FReLUNum, a, derivative: derivative, param1: @alpha)
+    end
+  end
+
+  class BReLUNum < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:BReLUNum, a, derivative: derivative)
+    end
+  end
+
+  class HardShrinkNum < BaseNumericOperation
+    def initialize(lambda: 0.5)
+      @lambda = lambda
+    end
+
+    def process(a, derivative: false)
+      execute_unary_operation(:HardShrinkNum, a, derivative: derivative, param1: @lambda)
+    end
+  end
+
+  class SoftShrinkNum < BaseNumericOperation
+    def initialize(lambda: 0.5)
+      @lambda = lambda
+    end
+
+    def process(a, derivative: false)
+      execute_unary_operation(:SoftShrinkNum, a, derivative: derivative, param1: @lambda)
+    end
+  end
+
+  class TanhShrinkNum < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:TanhShrinkNum, a, derivative: derivative)
+    end
+  end
+
+  class MaxoutNum < BaseNumericOperation
+    def initialize(num_pieces: 2)
+      @num_pieces = num_pieces
+    end
+
+    def process(a, derivative: false)
+      execute_unary_operation(:MaxoutNum, a, derivative: derivative, num_pieces: @num_pieces)
+    end
+  end
+
+  class MinoutNum < BaseNumericOperation
+    def initialize(num_pieces: 2)
+      @num_pieces = num_pieces
+    end
+
+    def process(a, derivative: false)
+      execute_unary_operation(:MinoutNum, a, derivative: derivative, num_pieces: @num_pieces)
+    end
+  end
+
+  class GLUNum < BaseNumericOperation
+    def initialize(dim: 1)
+      @dim = dim
+    end
+
+    def process(a, derivative: false)
+      execute_unary_operation(:GLUNum, a, derivative: derivative, num_pieces: @dim)
+    end
+  end
+
+  class ReLUSquaredNum < BaseNumericOperation
+    def process(a, derivative: false)
+      execute_unary_operation(:ReLUSquaredNum, a, derivative: derivative)
+    end
+  end
+end