galaaz 0.4.10 → 2.0.0

data/lib/R_interface/rlist.rb

@@ -29,14 +29,18 @@ module R
 
   class List < Object
     include IndexedObject
-    include Enumerable
-    
+    include ::Enumerable
+
+    def class
+      ::R::List
+    end
+
     #--------------------------------------------------------------------------------------
     #
     #--------------------------------------------------------------------------------------
     
     def +(other_object)
-      R::Support.exec_function_name("`+`", @r_interop, other_object.r_interop)
+      ::R::Support.exec_function_name("`+`", @r_interop, other_object.r_interop)
     end
 
     #--------------------------------------------------------------------------------------
@@ -48,20 +52,104 @@ module R
     end
 
     #--------------------------------------------------------------------------------------
-    # When indexing with '[' or '[[' an R object is returned.  Sometimes we need to have
-    # access to an umboxed Ruby element, for instance, in an numeric array, we might want
-    # to receive the actual number that can be used in a Ruby method.  In this case, we
-    # use the '<<' operator.
-    # @return the Ruby element at the given index in the vector
+    # Unbox list to Ruby. Recurses until only Ruby values (no R::Object in result).
+    # - index.nil? → whole list → Array of unboxed elements (single list → [x]).
+    # - index i   → list[[i+1]] unboxed (one Ruby value).
+    # Raises R::UnboxDepthError when recursion exceeds MAX_UNBOX_DEPTH (can be expensive).
     #--------------------------------------------------------------------------------------
+    def unboxed_get(index = nil, depth = 0)
+      if depth >= ::R::Support::MAX_UNBOX_DEPTH
+        ::Kernel.raise(::R::UnboxDepthError, "unbox: list too deep (max depth #{::R::Support::MAX_UNBOX_DEPTH} exceeded)")
+      end
+      if index.nil? && depth <= 1 && ::R.bridge.respond_to?(:unbox_materialize)
+        materialized = ::R.bridge.unbox_materialize(@r_interop,
+                                                    max_depth: ::R::Support::MAX_UNBOX_DEPTH,
+                                                    max_nodes: 200_000)
+        case materialized[:status]
+        when :ok
+          return materialized[:value]
+        when :depth_limit
+          ::Kernel.raise(::R::UnboxDepthError, "unbox: list too deep (max depth #{::R::Support::MAX_UNBOX_DEPTH} exceeded)")
+        when :node_limit
+          # Fall through to structural path if node budget is hit.
+        when :unsupported
+          # Fall through to structural path for mixed/unsupported types.
+        end
+      end
+      # Fast preflight for deep nested lists on the new bridge:
+      # detect depth overflow in one bridge call before recursive element reads.
+      if index.nil? && depth <= 1 && ::R.bridge.respond_to?(:unbox_walk)
+        walk = ::R.bridge.unbox_walk(@r_interop,
+                                     max_depth: ::R::Support::MAX_UNBOX_DEPTH,
+                                     max_nodes: 200_000)
+        if walk[:status] == :depth_limit
+          ::Kernel.raise(::R::UnboxDepthError, "unbox: list too deep (max depth #{::R::Support::MAX_UNBOX_DEPTH} exceeded)")
+        end
+      end
+      # NewBridge hardening path: use structural bridge reads during recursion.
+      if ::R.bridge.respond_to?(:unbox_list_length) && ::R.bridge.respond_to?(:unbox_list_element)
+        n = ::R.bridge.unbox_list_length(@r_interop)
+        if index.nil?
+          return [] if n <= 0
+          arr = []
+          (1..n).each do |i|
+            elt = ::R.bridge.unbox_list_element(@r_interop, i)
+            if elt.nil?
+              arr << nil
+            elsif !elt.is_a?(::R::Object)
+              arr << elt
+            else
+              arr << elt.unboxed_get(nil, depth + 1)
+            end
+          end
+          return arr
+        end
+
+        bound = n - 1
+        ::Kernel.raise(::IndexError.new("index #{index} out of list bounds: 0...#{bound}")) if index > bound
+        elt = ::R.bridge.unbox_list_element(@r_interop, index + 1)
+        return elt unless elt.is_a?(::R::Object)
+        return nil if elt.nil?
+        return nil if elt.respond_to?(:rclass) && elt.rclass.to_s.strip == 'NULL'
+        return elt.unboxed_get(nil, depth + 1)
+      end
+
+      if index.nil?
+        # Whole list → Array of unboxed elements (recurse into each element).
+        len_val = length
+        n = len_val.is_a?(::R::Vector) ? len_val.unboxed_get(0) : len_val
+        n = n.to_i if n.respond_to?(:to_i)
+        return [] unless n.is_a?(::Integer) && n >= 1
+        arr = []
+        (1..n).each do |i|
+          elt = self[[ [i] ]]
+          if elt.nil?
+            arr << nil
+          elsif !elt.is_a?(::R::Object)
+            arr << elt
+          else
+            arr << (elt.is__null.unboxed_get(0) ? nil : elt.unboxed_get(nil, depth + 1))
+          end
+        end
+        return arr
+      end
+
+      # Single element at index
+      bound_val = length
+      bound = bound_val.is_a?(::R::Vector) ? bound_val.unboxed_get(0) : bound_val
+      bound = bound.to_i - 1 if bound.respond_to?(:to_i)
+      bound = 0 if bound.nil? || !bound.is_a?(::Integer) || bound < 0
+      ::Kernel.raise(::IndexError.new("index #{index} out of list bounds: 0...#{bound}")) if index > bound
+      elt = self[[ [index + 1] ]]
+      return elt unless elt.is_a?(::R::Object)
+      return nil if (elt.is__null.respond_to?(:unboxed_get) ? elt.is__null.unboxed_get(0) : elt.is__null)
+      elt.unboxed_get(nil, depth + 1)
+    end
 
     def >>(index)
-      raise IndexError.new("index #{index} out of list bounds: 0...#{index - 1}") if
-        (index > (length - 1) >> 0)
-      raise ArgumentError.new("Indexed element is not a vector") if
-        !self[[index + 1]].is_a? R::Vector
-      return nil if (self[[index + 1]].is__null >> 0)
-      self[[index + 1]] >> 0
+      # Count the list root as depth 1 so MAX_UNBOX_DEPTH applies to list nesting
+      # the same way legacy unboxing specs expect.
+      unboxed_get(index, 1)
     end
 
     #--------------------------------------------------------------------------------------
@@ -71,12 +159,13 @@ module R
 
     def each
 
-      # length is a R::Vector, in order to extract its size as a Ruby number we need to
-      # use the >> operator
-      (1..length >> 0).each do |i|
-        yield self[[i]]
+      len = length
+      len = len.is_a?(::R::Vector) ? len.unboxed_get(0) : len
+      (1..len).each do |i|
+        # In Ruby list[[i]] is list.[]( [i] ) → single Array arg → we use R's [[ (element)
+        yield self[[ [i] ]]
       end
-      
+
     end
 
     #--------------------------------------------------------------------------------------
@@ -84,13 +173,14 @@ module R
     #--------------------------------------------------------------------------------------
 
     def each_with_index
-      
-      (1..length >> 0).each do |i|
-        yield self[[i]], i
+
+      len = length
+      len = len.is_a?(::R::Vector) ? len.unboxed_get(0) : len
+      (1..len).each do |i|
+        yield self[[ [i] ]], i
       end
-      
-    end
-    
+
+    end    
   end
   
   

data/lib/R_interface/rmatrix.rb

@@ -40,18 +40,9 @@ module R
     # logical operators. Can either be binary or unary
     include LogicalOperators
 
-    #--------------------------------------------------------------------------------------
-    # When indexing with '[' or '[[' an R object is returned.  Sometimes we need to have
-    # access to an umboxed Ruby element, for instance, in an numeric array, we might want
-    # to receive the actual number that can be used in a Ruby method.  In this case, we
-    # use the '<<' operator.
-    # @return the Ruby element at the given index in the vector
-    #--------------------------------------------------------------------------------------
-
-    def >>(index)
-      @r_interop[index]
+    def class
+      ::R::Matrix
     end
-
   end
   
 end

data/lib/R_interface/rmd_indexed_object.rb

@@ -36,7 +36,11 @@ module R
 
     def [](*index)
       if (index.size > 1)
-        R::Support.exec_function(R::Support.md_index, @r_interop, *index)
+        # DataFrame single-cell only when both indices are scalar (one row, one column): use [[ so R returns scalar
+        single_cell = index.size == 2 && self.is_a?(::R::DataFrame) &&
+          index[0].is_a?(::Integer) && (index[1].is_a?(::Integer) || index[1].is_a?(::String))
+        fn = single_cell ? R::Support.dbk_index : R::Support.md_index
+        R::Support.exec_function(fn, @r_interop, *index)
       else
         super(*index)
       end