ignis-numerics 0.0.1

data/lib/nvruby/sparse/sparse_matrix.rb

@@ -0,0 +1,456 @@
+# frozen_string_literal: true
+
+module Ignis
+  module Sparse
+    # Sparse matrix representation with multiple format support
+    class SparseMatrix
+      # @return [Symbol] Sparse format (:csr, :csc, :coo)
+      attr_reader :format
+
+      # @return [Array<Integer>] Matrix shape [rows, cols]
+      attr_reader :shape
+
+      # @return [Integer] Number of non-zero elements
+      attr_reader :nnz
+
+      # @return [Symbol] Data type
+      attr_reader :dtype
+
+      # @return [Integer] Device index
+      attr_reader :device_index
+
+      # CSR format: row_ptr, col_indices, values
+      # @return [CUDA::Memory, nil] Row pointer array
+      attr_reader :row_ptr
+
+      # @return [CUDA::Memory, nil] Column indices
+      attr_reader :col_indices
+
+      # @return [CUDA::Memory, nil] Row indices (for COO)
+      attr_reader :row_indices
+
+      # @return [CUDA::Memory, nil] Values array
+      attr_reader :values
+
+      # Create a sparse matrix in CSR format
+      # @param values [Array, NvArray] Non-zero values
+      # @param row_ptr [Array, NvArray] Row pointer array
+      # @param col_indices [Array, NvArray] Column indices
+      # @param shape [Array<Integer>] Matrix shape [rows, cols]
+      # @param dtype [Symbol] Data type
+      # @param device [Integer, nil] Device index
+      # @return [SparseMatrix]
+      def self.csr(values:, row_ptr:, col_indices:, shape:, dtype: :float32, device: nil)
+        matrix = new(format: :csr, shape: shape, nnz: values.size, dtype: dtype, device: device)
+        matrix.send(:initialize_csr, values, row_ptr, col_indices)
+        matrix
+      end
+
+      # Create a sparse matrix in COO format
+      # @param values [Array, NvArray] Non-zero values
+      # @param row_indices [Array, NvArray] Row indices
+      # @param col_indices [Array, NvArray] Column indices
+      # @param shape [Array<Integer>] Matrix shape [rows, cols]
+      # @param dtype [Symbol] Data type
+      # @param device [Integer, nil] Device index
+      # @return [SparseMatrix]
+      def self.coo(values:, row_indices:, col_indices:, shape:, dtype: :float32, device: nil)
+        matrix = new(format: :coo, shape: shape, nnz: values.size, dtype: dtype, device: device)
+        matrix.send(:initialize_coo, values, row_indices, col_indices)
+        matrix
+      end
+
+      # Create identity sparse matrix
+      # @param size [Integer] Matrix size
+      # @param dtype [Symbol] Data type
+      # @param device [Integer, nil] Device index
+      # @return [SparseMatrix]
+      def self.identity(size, dtype: :float32, device: nil)
+        values = Array.new(size, 1.0)
+        row_ptr = (0..size).to_a
+        col_indices = (0...size).to_a
+
+        csr(values: values, row_ptr: row_ptr, col_indices: col_indices,
+            shape: [size, size], dtype: dtype, device: device)
+      end
+
+      # Create sparse matrix from dense NvArray
+      # @param dense [NvArray] Dense matrix
+      # @param format [Symbol] Output format (:csr or :coo)
+      # @param threshold [Float] Values below this are treated as zero
+      # @return [SparseMatrix]
+      def self.from_dense(dense, format: :csr, threshold: 0.0)
+        raise ArgumentError, "Expected NvArray, got #{dense.class}" unless dense.is_a?(NvArray)
+        raise DimensionError, "Expected 2D array, got #{dense.ndim}D" unless dense.ndim == 2
+
+        dense = dense.to_host unless dense.on_host?
+        data = dense.flatten
+
+        rows, cols = dense.shape
+        row_indices = []
+        col_indices_arr = []
+        values_arr = []
+
+        data.each_with_index do |val, idx|
+          next if val.abs <= threshold
+
+          row_indices << idx / cols
+          col_indices_arr << idx % cols
+          values_arr << val
+        end
+
+        if format == :csr
+          # Convert row indices to row pointer
+          row_ptr = Array.new(rows + 1, 0)
+          row_indices.each { |r| row_ptr[r + 1] += 1 }
+          (1..rows).each { |i| row_ptr[i] += row_ptr[i - 1] }
+
+          csr(values: values_arr, row_ptr: row_ptr, col_indices: col_indices_arr,
+              shape: [rows, cols], dtype: dense.dtype, device: dense.device_index)
+        else
+          coo(values: values_arr, row_indices: row_indices, col_indices: col_indices_arr,
+              shape: [rows, cols], dtype: dense.dtype, device: dense.device_index)
+        end
+      end
+
+      # @return [Integer] Number of rows
+      def rows
+        @shape[0]
+      end
+
+      # @return [Integer] Number of columns
+      def cols
+        @shape[1]
+      end
+
+      # Sparsity ratio
+      # @return [Float] Fraction of elements that are zero
+      def sparsity
+        1.0 - (@nnz.to_f / (rows * cols))
+      end
+
+      # Density ratio
+      # @return [Float] Fraction of elements that are non-zero
+      def density
+        @nnz.to_f / (rows * cols)
+      end
+
+      # Transfer to GPU
+      # @param device [Integer, nil] Target device
+      # @return [self]
+      def to_device(device: nil)
+        target_device = device || @device_index
+
+        case @format
+        when :csr
+          transfer_csr_to_device(target_device)
+        when :coo
+          transfer_coo_to_device(target_device)
+        end
+
+        @device_index = target_device
+        @on_device = true
+        self
+      end
+
+      # Transfer data to host
+      # @return [self]
+      def to_host
+        return self unless on_device?
+
+        # Currently we don't support device-side mutation of sparse structures
+        # so the host copy is already up to date. We just free device memory.
+        free!
+        self
+      end
+
+      # Check if on device
+      # @return [Boolean]
+      def on_device?
+        @on_device
+      end
+
+      # Convert to dense NvArray
+      # @return [NvArray] Dense matrix
+      def to_dense
+        result = NvArray.zeros(@shape, dtype: @dtype, device: nil)
+
+        case @format
+        when :csr
+          expand_csr_to_dense(result)
+        when :coo
+          expand_coo_to_dense(result)
+        end
+
+        result
+      end
+
+      # Sparse matrix-vector multiplication: y = alpha * A * x + beta * y
+      # @param x [NvArray] Input vector
+      # @param y [NvArray, nil] Output vector (created if nil)
+      # @param alpha [Float] Scaling factor for A*x
+      # @param beta [Float] Scaling factor for y
+      # @param transpose [Boolean] Transpose A
+      # @return [NvArray] Result vector
+      def spmv(x, y: nil, alpha: 1.0, beta: 0.0, transpose: false)
+        raise ArgumentError, "Expected NvArray, got #{x.class}" unless x.is_a?(NvArray)
+
+        out_rows = transpose ? cols : rows
+        in_cols = transpose ? rows : cols
+
+        raise DimensionError, "Vector size #{x.size} != matrix cols #{in_cols}" unless x.size == in_cols
+
+        to_device unless on_device?
+        x = x.to_device unless x.on_device?
+
+        y ||= NvArray.zeros([out_rows], dtype: @dtype, device: @device_index)
+        y = y.to_device unless y.on_device?
+
+        execute_spmv(x, y, alpha, beta, transpose)
+
+        y
+      end
+
+      # Free all memory
+      # @return [void]
+      def free!
+        @row_ptr&.free!
+        @col_indices&.free!
+        @row_indices&.free!
+        @values&.free!
+
+        @row_ptr = nil
+        @col_indices = nil
+        @row_indices = nil
+        @values = nil
+        @on_device = false
+      end
+
+      # @return [String]
+      def to_s
+        "SparseMatrix(shape=#{@shape}, nnz=#{@nnz}, format=#{@format}, density=#{(density * 100).round(2)}%)"
+      end
+
+      private
+
+      def initialize(format:, shape:, nnz:, dtype:, device:)
+        @format = format
+        @shape = Array(shape)
+        @nnz = nnz
+        @dtype = DType.validate!(dtype)
+        @device_index = device || Ignis.configuration.default_device
+        @on_device = false
+      end
+
+      # Initialize CSR format arrays
+      def initialize_csr(values, row_ptr, col_indices)
+        @values_host = to_flat_array(values)
+        @row_ptr_host = to_int_array(row_ptr)
+        @col_indices_host = to_int_array(col_indices)
+      end
+
+      # Initialize COO format arrays
+      def initialize_coo(values, row_indices, col_indices)
+        @values_host = to_flat_array(values)
+        @row_indices_host = to_int_array(row_indices)
+        @col_indices_host = to_int_array(col_indices)
+      end
+
+      # Convert to flat array
+      def to_flat_array(data)
+        case data
+        when NvArray
+          data.flatten
+        when Array
+          data.flatten
+        else
+          Array(data)
+        end
+      end
+
+      # Convert to integer array
+      def to_int_array(data)
+        to_flat_array(data).map(&:to_i)
+      end
+
+      # Transfer CSR data to device
+      def transfer_csr_to_device(device)
+        # Values
+        @values = CUDA::Memory.new(@nnz * DType.byte_size(@dtype), device: device)
+        values_ptr = create_host_pointer(@values_host, DType.ffi_type(@dtype))
+        @values.copy_from_host(values_ptr)
+
+        # Row pointer (int32)
+        @row_ptr = CUDA::Memory.new((rows + 1) * 4, device: device)
+        row_ptr_ffi = FFI::MemoryPointer.new(:int32, rows + 1)
+        @row_ptr_host.each_with_index { |v, i| row_ptr_ffi.put_int32(i * 4, v) }
+        @row_ptr.copy_from_host(row_ptr_ffi)
+
+        # Column indices (int32)
+        @col_indices = CUDA::Memory.new(@nnz * 4, device: device)
+        col_ind_ffi = FFI::MemoryPointer.new(:int32, @nnz)
+        @col_indices_host.each_with_index { |v, i| col_ind_ffi.put_int32(i * 4, v) }
+        @col_indices.copy_from_host(col_ind_ffi)
+      end
+
+      # Transfer COO data to device
+      def transfer_coo_to_device(device)
+        # Values
+        @values = CUDA::Memory.new(@nnz * DType.byte_size(@dtype), device: device)
+        values_ptr = create_host_pointer(@values_host, DType.ffi_type(@dtype))
+        @values.copy_from_host(values_ptr)
+
+        # Row indices (int32)
+        @row_indices = CUDA::Memory.new(@nnz * 4, device: device)
+        row_ind_ffi = FFI::MemoryPointer.new(:int32, @nnz)
+        @row_indices_host.each_with_index { |v, i| row_ind_ffi.put_int32(i * 4, v) }
+        @row_indices.copy_from_host(row_ind_ffi)
+
+        # Column indices (int32)
+        @col_indices = CUDA::Memory.new(@nnz * 4, device: device)
+        col_ind_ffi = FFI::MemoryPointer.new(:int32, @nnz)
+        @col_indices_host.each_with_index { |v, i| col_ind_ffi.put_int32(i * 4, v) }
+        @col_indices.copy_from_host(col_ind_ffi)
+      end
+
+      # Create host pointer for values
+      def create_host_pointer(data, ffi_type)
+        ptr = FFI::MemoryPointer.new(ffi_type, data.size)
+        data.each_with_index do |v, i|
+          case ffi_type
+          when :float then ptr.put_float(i * 4, v)
+          when :double then ptr.put_double(i * 8, v)
+          end
+        end
+        ptr
+      end
+
+      # Expand CSR to dense
+      def expand_csr_to_dense(result)
+        result_data = Array.new(rows * cols, 0.0)
+
+        rows.times do |row|
+          start_idx = @row_ptr_host[row]
+          end_idx = @row_ptr_host[row + 1]
+
+          (start_idx...end_idx).each do |idx|
+            col = @col_indices_host[idx]
+            result_data[row * cols + col] = @values_host[idx]
+          end
+        end
+
+        result.instance_variable_get(:@host_memory).tap do |ptr|
+          result_data.each_with_index do |v, i|
+            ptr.put_float(i * 4, v)
+          end
+        end
+      end
+
+      # Expand COO to dense
+      def expand_coo_to_dense(result)
+        result_data = Array.new(rows * cols, 0.0)
+
+        @nnz.times do |idx|
+          row = @row_indices_host[idx]
+          col = @col_indices_host[idx]
+          result_data[row * cols + col] = @values_host[idx]
+        end
+
+        result.instance_variable_get(:@host_memory).tap do |ptr|
+          result_data.each_with_index do |v, i|
+            ptr.put_float(i * 4, v)
+          end
+        end
+      end
+
+      # Execute sparse matrix-vector multiplication
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def execute_spmv(x, y, alpha, beta, transpose)
+        CuSPARSEBindings.ensure_loaded!
+        handle = CuSPARSEBindings.get_handle
+
+        # Create sparse matrix descriptor
+        sp_mat_ptr = FFI::MemoryPointer.new(:pointer)
+        value_type = @dtype == :float32 ? 0 : 1 # CUDA_R_32F or CUDA_R_64F
+
+        if @format == :csr
+          status = CuSPARSEBindings.cusparseCreateCsr(
+            sp_mat_ptr,
+            rows, cols, @nnz,
+            @row_ptr.device_ptr,
+            @col_indices.device_ptr,
+            @values.device_ptr,
+            CuSPARSEBindings::CUSPARSE_INDEX_32I,
+            CuSPARSEBindings::CUSPARSE_INDEX_32I,
+            CuSPARSEBindings::CUSPARSE_INDEX_BASE_ZERO,
+            value_type
+          )
+        else
+          status = CuSPARSEBindings.cusparseCreateCoo(
+            sp_mat_ptr,
+            rows, cols, @nnz,
+            @row_indices.device_ptr,
+            @col_indices.device_ptr,
+            @values.device_ptr,
+            CuSPARSEBindings::CUSPARSE_INDEX_32I,
+            CuSPARSEBindings::CUSPARSE_INDEX_BASE_ZERO,
+            value_type
+          )
+        end
+        CuSPARSEBindings.check_status!(status, "Create sparse matrix descriptor")
+        sp_mat = sp_mat_ptr.read_pointer
+
+        # Create dense vector descriptors
+        vec_x_ptr = FFI::MemoryPointer.new(:pointer)
+        status = CuSPARSEBindings.cusparseCreateDnVec(vec_x_ptr, x.size, x.device_ptr, value_type)
+        CuSPARSEBindings.check_status!(status, "Create dense vector X")
+        vec_x = vec_x_ptr.read_pointer
+
+        vec_y_ptr = FFI::MemoryPointer.new(:pointer)
+        status = CuSPARSEBindings.cusparseCreateDnVec(vec_y_ptr, y.size, y.device_ptr, value_type)
+        CuSPARSEBindings.check_status!(status, "Create dense vector Y")
+        vec_y = vec_y_ptr.read_pointer
+
+        # Prepare scalars
+        alpha_ptr = FFI::MemoryPointer.new(@dtype == :float32 ? :float : :double)
+        beta_ptr = FFI::MemoryPointer.new(@dtype == :float32 ? :float : :double)
+
+        if @dtype == :float32
+          alpha_ptr.put_float(0, alpha)
+          beta_ptr.put_float(0, beta)
+        else
+          alpha_ptr.put_double(0, alpha)
+          beta_ptr.put_double(0, beta)
+        end
+
+        # Get buffer size
+        buffer_size_ptr = FFI::MemoryPointer.new(:size_t)
+        op = transpose ? CuSPARSEBindings::CUSPARSE_OPERATION_TRANSPOSE : CuSPARSEBindings::CUSPARSE_OPERATION_NON_TRANSPOSE
+
+        status = CuSPARSEBindings.cusparseSpMV_bufferSize(
+          handle, op, alpha_ptr, sp_mat, vec_x, beta_ptr, vec_y,
+          value_type, CuSPARSEBindings::CUSPARSE_SPMV_ALG_DEFAULT, buffer_size_ptr
+        )
+        CuSPARSEBindings.check_status!(status, "Get SpMV buffer size")
+
+        buffer_size = buffer_size_ptr.read(:size_t)
+        buffer = buffer_size.positive? ? CUDA::Memory.new(buffer_size, device: @device_index) : nil
+
+        # Execute SpMV
+        status = CuSPARSEBindings.cusparseSpMV(
+          handle, op, alpha_ptr, sp_mat, vec_x, beta_ptr, vec_y,
+          value_type, CuSPARSEBindings::CUSPARSE_SPMV_ALG_DEFAULT,
+          buffer&.device_ptr || FFI::Pointer::NULL
+        )
+        CuSPARSEBindings.check_status!(status, "Execute SpMV")
+
+        # Cleanup
+        CuSPARSEBindings.cusparseDestroySpMat(sp_mat)
+        CuSPARSEBindings.cusparseDestroyDnVec(vec_x)
+        CuSPARSEBindings.cusparseDestroyDnVec(vec_y)
+        buffer&.free!
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+    end
+  end
+end

data/lib/nvruby/tensor/contraction.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require_relative "../linalg/cutensor_bindings"
+
+module Ignis
+  module Tensor
+    # Tensor contraction operation using cuTENSOR
+    # Supports Einstein notation for expressing tensor contractions
+    #
+    # @example Matrix multiplication (ij,jk->ik)
+    #   contraction = Contraction.new("ij,jk->ik", a, b)
+    #   result = contraction.execute
+    #   contraction.destroy!
+    class Contraction
+      # @return [String] Einstein notation expression
+      attr_reader :expression
+
+      # @return [NvArray] First input tensor
+      attr_reader :tensor_a
+
+      # @return [NvArray] Second input tensor
+      attr_reader :tensor_b
+
+      # @return [Array<Integer>] Output shape
+      attr_reader :output_shape
+
+      # Parse Einstein notation expression
+      # @param expression [String] Expression like "ij,jk->ik"
+      # @return [Hash] Parsed components
+      def self.parse_expression(expression)
+        unless expression.include?(",") && expression.include?("->")
+          raise ArgumentError, "Invalid Einstein notation: #{expression}. Expected format: 'ij,jk->ik'"
+        end
+
+        input_part, output_modes = expression.split("->")
+        input_a_modes, input_b_modes = input_part.split(",")
+
+        {
+          input_a_modes: input_a_modes.chars,
+          input_b_modes: input_b_modes.chars,
+          output_modes: output_modes.chars,
+          contracted_modes: (input_a_modes.chars & input_b_modes.chars) - output_modes.chars
+        }
+      end
+
+      # Initialize tensor contraction
+      # @param expression [String] Einstein notation expression
+      # @param tensor_a [NvArray] First input tensor
+      # @param tensor_b [NvArray] Second input tensor
+      # @param alpha [Float] Scaling factor
+      # @param beta [Float] Scaling for output (for accumulation)
+      def initialize(expression, tensor_a, tensor_b, alpha: 1.0, beta: 0.0)
+        @expression = expression
+        @tensor_a = tensor_a
+        @tensor_b = tensor_b
+        @alpha = alpha
+        @beta = beta
+        @parsed = self.class.parse_expression(expression)
+        @planned = false
+        @handle = nil
+        @plan = nil
+
+        validate_inputs!
+        compute_output_shape!
+      end
+
+      # Execute the tensor contraction
+      # @return [NvArray] Result tensor
+      def execute
+        # Ensure tensors are on device
+        a = @tensor_a.on_device? ? @tensor_a : @tensor_a.to_device
+        b = @tensor_b.on_device? ? @tensor_b : @tensor_b.to_device
+
+        # Create output tensor
+        output = NvArray.zeros(@output_shape, dtype: a.dtype, device: a.device_index)
+        output = output.to_device unless output.on_device?
+
+        # For now, use optimized path for common patterns
+        # Full cuTENSOR integration will use the plan/execute pattern
+        if matrix_multiply?
+          execute_as_matmul(a, b, output)
+        else
+          execute_general_contraction(a, b, output)
+        end
+
+        output
+      end
+
+      # Free cuTENSOR resources
+      # @return [void]
+      def destroy!
+        @handle = nil
+        @plan = nil
+        @planned = false
+      end
+
+      private
+
+      # Validate input tensors
+      def validate_inputs!
+        unless @tensor_a.is_a?(NvArray) && @tensor_b.is_a?(NvArray)
+          raise ArgumentError, "Expected NvArray tensors"
+        end
+
+        unless @tensor_a.dtype == @tensor_b.dtype
+          raise ArgumentError, "Tensor dtypes must match: #{@tensor_a.dtype} vs #{@tensor_b.dtype}"
+        end
+
+        a_modes = @parsed[:input_a_modes]
+        b_modes = @parsed[:input_b_modes]
+
+        unless @tensor_a.ndim == a_modes.size
+          raise DimensionError, "Tensor A has #{@tensor_a.ndim} dims but expression specifies #{a_modes.size} modes"
+        end
+
+        unless @tensor_b.ndim == b_modes.size
+          raise DimensionError, "Tensor B has #{@tensor_b.ndim} dims but expression specifies #{b_modes.size} modes"
+        end
+      end
+
+      # Compute output tensor shape based on expression
+      def compute_output_shape!
+        mode_extents = {}
+
+        # Map modes to extents from input tensors
+        @parsed[:input_a_modes].each_with_index do |mode, idx|
+          mode_extents[mode] = @tensor_a.shape[idx]
+        end
+
+        @parsed[:input_b_modes].each_with_index do |mode, idx|
+          if mode_extents[mode] && mode_extents[mode] != @tensor_b.shape[idx]
+            raise DimensionError, "Mode '#{mode}' has inconsistent extents: #{mode_extents[mode]} vs #{@tensor_b.shape[idx]}"
+          end
+          mode_extents[mode] = @tensor_b.shape[idx]
+        end
+
+        # Build output shape
+        @output_shape = @parsed[:output_modes].map do |mode|
+          extent = mode_extents[mode]
+          raise ArgumentError, "Output mode '#{mode}' not found in inputs" unless extent
+
+          extent
+        end
+      end
+
+      # Check if this is a simple matrix multiplication
+      # @return [Boolean]
+      def matrix_multiply?
+        @expression == "ij,jk->ik" || @expression == "ik,kj->ij"
+      end
+
+      # Execute as matrix multiplication using cuBLAS (faster for 2D)
+      def execute_as_matmul(a, b, output)
+        # Use cuBLAS for matrix multiply - much faster
+        c = LinAlg::Matmul.call(a, b, c: output, alpha: @alpha, beta: @beta)
+        # Copy result back if needed
+        output.instance_variable_set(:@device_ptr, c.device_ptr) if c != output
+      end
+
+      # Execute general tensor contraction using cuTENSOR
+      def execute_general_contraction(a, b, output)
+        # For general contractions, we use a transpose + reshape + matmul approach
+        # This is the "TTGT" (Transpose-Transpose-GEMM-Transpose) algorithm
+        # Full cuTENSOR integration would use cutensorContract directly
+
+        # For MVP, fall back to matmul by reshaping
+        # This handles many common cases efficiently
+        perform_ttgt_contraction(a, b, output)
+      end
+
+      # TTGT: Transpose-Transpose-GEMM-Transpose algorithm for general contractions
+      def perform_ttgt_contraction(a, b, output)
+        contracted = @parsed[:contracted_modes]
+        a_modes = @parsed[:input_a_modes]
+        b_modes = @parsed[:input_b_modes]
+        out_modes = @parsed[:output_modes]
+
+        # Find free indices for A and B
+        a_free = a_modes - contracted
+        b_free = b_modes - contracted
+
+        # For simple cases, reshape and use matmul
+        if contracted.size == 1 && a_free.size == 1 && b_free.size == 1
+          # Standard matrix multiply pattern
+          m = a.shape[a_modes.index(a_free[0])]
+          k = a.shape[a_modes.index(contracted[0])]
+          n = b.shape[b_modes.index(b_free[0])]
+
+          # Reshape if needed and do matmul
+          a_2d = a.reshape([m, k])
+          b_2d = b.reshape([k, n])
+
+          result = LinAlg::Matmul.call(a_2d, b_2d, alpha: @alpha, beta: @beta)
+
+          # Reshape output to correct shape
+          if result.shape != @output_shape
+            result = result.reshape(@output_shape)
+          end
+
+          # Copy to output
+          copy_to_output(result, output)
+        else
+          # More complex contractions - requires full cuTENSOR
+          # For now, raise an informative error
+          raise NotImplementedError, "Complex contraction '#{@expression}' requires full cuTENSOR integration. " \
+                                     "Supported patterns: 'ij,jk->ik' (matmul), single-index contractions."
+        end
+      end
+
+      # Copy result data to output tensor
+      def copy_to_output(source, dest)
+        # Direct device memory copy
+        byte_size = source.size * DType.byte_size(source.dtype)
+        CUDA::RuntimeAPI.memcpy_device_to_device(dest.device_ptr, source.device_ptr, byte_size)
+      end
+    end
+  end
+end