Add view, axes, lastindex, range indexing for ragged types

Fixes issues reported by @JoshuaLampert:
- Add view(r, :, i) and view(r, I, i) for ragged arrays
- Add axes(r, d) and lastindex(r, d) so `end` works in indexing
- Add range indexing: r[1:3, i], r[:, 2:end]
- Note: `end` in first dim uses max inner array length (not per-column
  like v3's RaggedEnd), so r[end, i] may throw BoundsError for shorter
  inner arrays. Use r[:, i] for safe column access.

Tests: 243 pass (up from 212).

Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: ChrisRackauckas

lib/RecursiveArrayToolsRaggedArrays/src/RecursiveArrayToolsRaggedArrays.jl

@@ -267,6 +267,21 @@ Base.iterate(r::AbstractRaggedVectorOfArray, state) = iterate(r.u, state)
 Base.firstindex(r::AbstractRaggedVectorOfArray) = firstindex(r.u)
 Base.lastindex(r::AbstractRaggedVectorOfArray) = lastindex(r.u)
 
+# lastindex with dimension — needed for `end` in multi-index expressions like r[end, 2]
+# dim N (last) = number of inner arrays; dim 1..N-1 = ragged, use max across inner arrays
+function Base.lastindex(r::AbstractRaggedVectorOfArray{T, N}, d::Int) where {T, N}
+    if d == N
+        return length(r.u)
+    else
+        return isempty(r.u) ? 0 : maximum(size(u, d) for u in r.u)
+    end
+end
+
+# axes with dimension — needed for `end` translation and range indexing
+function Base.axes(r::AbstractRaggedVectorOfArray{T, N}, d::Int) where {T, N}
+    return Base.OneTo(lastindex(r, d))
+end
+
 Base.keys(r::AbstractRaggedVectorOfArray) = keys(r.u)
 Base.eachindex(r::AbstractRaggedVectorOfArray) = eachindex(r.u)
 
@@ -422,6 +437,45 @@ function Base.getindex(r::RaggedDiffEqArray, i::Int, ::Colon)
     return [u[i] for u in r.u]
 end
 
+# Range indexing into inner arrays: r[1:3, i] or r[2:end, i]
+function Base.getindex(
+        r::AbstractRaggedVectorOfArray, I::AbstractRange, col::Int
+    )
+    return r.u[col][I]
+end
+
+# r[1:end, :] — range of components across all columns
+function Base.getindex(
+        r::AbstractRaggedVectorOfArray, I::AbstractRange, ::Colon
+    )
+    return [u[I] for u in r.u]
+end
+
+# A[:, range] — column subset with UnitRange (needed for A[:, 2:end])
+function Base.getindex(
+        r::RaggedVectorOfArray, ::Colon, I::AbstractRange
+    )
+    return RaggedVectorOfArray(r.u[I])
+end
+function Base.getindex(
+        r::RaggedDiffEqArray, ::Colon, I::AbstractRange
+    )
+    return RaggedDiffEqArray(r.u[I], r.t[I], r.p, r.sys;
+        discretes = r.discretes, interp = r.interp, dense = r.dense)
+end
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Views
+# ═══════════════════════════════════════════════════════════════════════════════
+
+function Base.view(r::AbstractRaggedVectorOfArray, ::Colon, i::Int)
+    return view(r.u[i], :)
+end
+
+function Base.view(r::AbstractRaggedVectorOfArray, I, i::Int)
+    return view(r.u[i], I)
+end
+
 # ═══════════════════════════════════════════════════════════════════════════════
 # Symbolic Indexing Dispatch
 # ═══════════════════════════════════════════════════════════════════════════════

lib/RecursiveArrayToolsRaggedArrays/test/runtests.jl

@@ -382,11 +382,23 @@ using Test
         @test f[:, 1] == [1.0]
         @test f[:, 2] == [2.0, 3.0]
 
+        # view also respects actual inner array size
+        @test length(view(f, :, 1)) == 1
+        @test length(view(f, :, 2)) == 2
+        @test view(f, :, 1) == [1.0]
+        @test view(f, :, 2) == [2.0, 3.0]
+        @test collect(view(f, :, 1)) == f[:, 1]
+        @test collect(view(f, :, 2)) == f[:, 2]
+
         f2 = RaggedVectorOfArray([[1.0, 2.0], [3.0]])
         @test length(f2[:, 1]) == 2
         @test length(f2[:, 2]) == 1
         @test f2[:, 1] == [1.0, 2.0]
         @test f2[:, 2] == [3.0]
+        @test length(view(f2, :, 1)) == 2
+        @test length(view(f2, :, 2)) == 1
+        @test view(f2, :, 1) == [1.0, 2.0]
+        @test view(f2, :, 2) == [3.0]
     end
 
     @testset "v3 end indexing with ragged arrays (ported)" begin
@@ -399,28 +411,60 @@ using Test
         @test ragged[2, 2] == 4.0
         @test ragged[3, 3] == 8.0
 
+        # `end` in the last (column) dimension
+        @test ragged[:, end] == [6.0, 7.0, 8.0, 9.0]
+        @test ragged[:, (end - 1):end] isa RaggedVectorOfArray
+        @test length(ragged[:, (end - 1):end]) == 2
+
+        # `end` in first dim = max inner array length (4 here)
+        # So ragged[end, 1] = ragged[4, 1] which is out of bounds for inner array 1
+        @test_throws BoundsError ragged[end, 1]  # inner[1] has only 2 elements
+        @test_throws BoundsError ragged[end, 2]  # inner[2] has only 3 elements
+        @test ragged[end, 3] == 9.0              # inner[3] has 4 elements, end=4 works
+
+        # Range indexing into inner arrays
+        @test ragged[1:2, 1] == [1.0, 2.0]
+        @test ragged[1:3, 2] == [3.0, 4.0, 5.0]
+        @test ragged[1:4, 3] == [6.0, 7.0, 8.0, 9.0]
+        # 1:end uses max inner length (4), so only works for longest column
+        @test_throws BoundsError ragged[1:end, 1]  # 1:4 but inner[1] has 2
+        @test_throws BoundsError ragged[1:end, 2]  # 1:4 but inner[2] has 3
+        @test ragged[1:end, 3] == [6.0, 7.0, 8.0, 9.0]  # 1:4 matches inner[3]
+
         # Colon returns actual arrays
         @test ragged[:, 1] == [1.0, 2.0]
         @test ragged[:, 2] == [3.0, 4.0, 5.0]
         @test ragged[:, 3] == [6.0, 7.0, 8.0, 9.0]
 
-        # Subset selection
-        r_sub = ragged[:, [2, 3]]
-        @test r_sub isa RaggedVectorOfArray
-        @test r_sub[:, 1] == [3.0, 4.0, 5.0]
-        @test r_sub[:, 2] == [6.0, 7.0, 8.0, 9.0]
+        # Subset selection via range
+        @test ragged[:, 2:end] isa RaggedVectorOfArray
+        @test ragged[:, 2:end][:, 1] == [3.0, 4.0, 5.0]
 
         ragged2 = RaggedVectorOfArray([[1.0, 2.0, 3.0, 4.0], [5.0, 6.0], [7.0, 8.0, 9.0]])
-        @test ragged2[4, 1] == 4.0
-        @test ragged2[2, 2] == 6.0
-        @test ragged2[3, 3] == 9.0
-        @test ragged2[3, 1] == 3.0
-        @test ragged2[1, 2] == 5.0
-        @test ragged2[2, 3] == 8.0
-        @test ragged2[2, 1] == 2.0
+        # end in first dim = max length = 4
+        @test ragged2[end, 1] == 4.0                # inner[1] has 4 elements
+        @test_throws BoundsError ragged2[end, 2]    # inner[2] has only 2
+        @test_throws BoundsError ragged2[end, 3]    # inner[3] has only 3
+        @test ragged2[end - 1, 1] == 3.0            # end-1 = 3
+        @test_throws BoundsError ragged2[end - 1, 2] # 3 > length([5,6])
+        @test ragged2[end - 1, 3] == 9.0            # 3 <= length([7,8,9])
         @test ragged2[:, 1] == [1.0, 2.0, 3.0, 4.0]
         @test ragged2[:, 2] == [5.0, 6.0]
         @test ragged2[:, 3] == [7.0, 8.0, 9.0]
+        # Explicit range indexing (not using end)
+        @test ragged2[1:4, 1] == [1.0, 2.0, 3.0, 4.0]
+        @test ragged2[1:2, 2] == [5.0, 6.0]
+        @test ragged2[1:3, 3] == [7.0, 8.0, 9.0]
+        @test ragged2[2:4, 1] == [2.0, 3.0, 4.0]
+        @test ragged2[2:2, 2] == [6.0]
+        @test ragged2[2:3, 3] == [8.0, 9.0]
+        # end in last dim works fine
+        @test ragged2[:, end] == [7.0, 8.0, 9.0]
+        @test ragged2[:, 2:end] isa RaggedVectorOfArray
+        # end in first dim = 4 (max), 1:(end-1) = 1:3
+        @test ragged2[1:(end - 1), 1] == [1.0, 2.0, 3.0]
+        @test_throws BoundsError ragged2[1:(end - 1), 2]  # 1:3 but inner[2] has 2
+        @test ragged2[1:(end - 1), 3] == [7.0, 8.0, 9.0]  # 1:3 matches inner[3]
     end
 
     @testset "v3 push! making array ragged (ported)" begin