Use Base.CartesianIndex.

Author: maleadt

src/device/indexing.jl

@@ -90,12 +90,12 @@ end
 """
     cartesianidx(A, ctxsym = :ctx)
 
-Like [`@linearidx(A, ctxsym = :ctx)`](@ref), but returns an N-dimensional `NTuple{ndim(A), Int}` as index
+Like [`@linearidx(A, ctxsym = :ctx)`](@ref), but returns a N-dimensional `CartesianIndex`.
 """
 macro cartesianidx(A, ctxsym = :ctx)
     quote
         x = $(esc(A))
-        i2 = @linearidx(x, $(esc(ctxsym)))
-        gpu_ind2sub(x, i2)
+        i = @linearidx(x, $(esc(ctxsym)))
+        CartesianIndices(x)[i]
     end
 end

src/host/linalg.jl

@@ -9,15 +9,15 @@ function LinearAlgebra.transpose!(At::AbstractGPUArray{T, 2}, A::AbstractGPUArra
     At
 end
 
-function genperm(I::NTuple{N}, perm::NTuple{N}) where N
-    ntuple(d-> (@inbounds return I[perm[d]]), Val(N))
+function genperm(I::CartesianIndex{N}, perm::NTuple{N}) where N
+    CartesianIndex(ntuple(d-> (@inbounds return I[perm[d]]), Val(N)))
 end
 
 function LinearAlgebra.permutedims!(dest::AbstractGPUArray, src::AbstractGPUArray, perm) where N
     perm isa Tuple || (perm = Tuple(perm))
     gpu_call(dest, src, perm) do ctx, dest, src, perm
         I = @cartesianidx src ctx
-        @inbounds dest[genperm(I, perm)...] = src[I...]
+        @inbounds dest[genperm(I, perm)] = src[I]
         return
     end
     return dest

src/host/math.jl

@@ -3,7 +3,7 @@ import Base.clamp!
 function Base.clamp!(A::AbstractGPUArray, low, high)
     function kernel(state, A, low, high)
         I = @cartesianidx A state
-        A[I...] = clamp(A[I...], low, high)
+        A[I] = clamp(A[I], low, high)
         return
     end
     gpu_call(kernel, A, low, high)