Performance Optimization

1. reuse `CartesianIndices`'s `simd_index`
2. make 4d `@simd` faster (I don't know why)

Author: N5N3

base/multidimensional.jl

@@ -613,32 +613,28 @@ module IteratorsMD
     end
 
     @inline function simd_outer_range(iter::CartesianPartition)
-        # In general, the Cartesian Partition might start and stop in the middle of the outer
-        # dimensions — thus the outer range of a CartesianPartition is itself a
-        # CartesianPartition.
+        # In general, the CartesianPartition might start and stop in the middle of the outer
+        # dimensions, thus the outer range itself is a CartesianPartition.
         piter = iter.parent.parent
         ci = CartesianIndices(tail(piter.indices))
         size1 = size(piter, 1)
-        offsetʷ = firstindex(piter) - 1
-        vindʷ = only(iter.indices) .- offsetʷ
-        offsetᵒ = firstindex(ci) - 1
-        vindᵒ = cld(first(vindʷ) , size1) : cld(last(vindʷ), size1)
+        vindʷ = only(iter.indices) .- firstindex(piter) .+ 1
+        d₁, r₁ = divrem(first(vindʷ), size1, RoundUp)
+        d₂, r₂ = divrem(last(vindʷ) , size1, RoundUp)
+        vindᵒ = (d₁:d₂) .+ firstindex(ci) .- 1
+        outer = @inbounds view(ci, vindᵒ)
         # Use Generator to make inner loop branchless
         @inline function genouter(i::Int, I::CartesianIndex)
-            l, r = first(vindᵒ), last(vindᵒ)
-            skip = i == 1 ? first(vindʷ) - 1 - (l - 1) * size1 : 0
-            len = i == length(vindᵒ) ? last(vindʷ) - (r - 1) * size1 : size1
+            skip = i == 1 ? r₁ + size1 - 1 : 0
+            #TODO == d₂ - d₁ + 1 and == length(outer) is slower for 4d case
+            len = i == length(vindᵒ) ? r₂ + size1 : size1
             skip, len - skip, I
         end
-        outer = @inbounds view(ci, vindᵒ .+ offsetᵒ)
         (genouter(i, I) for (i, I) in Iterators.enumerate(outer))
     end
-    @inline simd_inner_length(iter::CartesianPartition, (skip, len, I)::Tuple{Int,Int,CartesianIndex}) = len
-    @inline function simd_index(iter::CartesianPartition, (skip, len, I)::Tuple{Int,Int,CartesianIndex}, n::Int)
-        inner = first(iter.parent.parent.indices)
-        n += skip + firstindex(inner)
-        @inbounds CartesianIndex(inner[n], I)
-    end
+    @inline simd_inner_length(iter::CartesianPartition, (_, len, _)::Tuple{Int,Int,CartesianIndex}) = len
+    @propagate_inbounds simd_index(iter::CartesianPartition, (skip, _, I)::Tuple{Int,Int,CartesianIndex}, n::Int) =
+        simd_index(iter.parent.parent, I, n + skip)
 end  # IteratorsMD