Merge pull request #213 from JuliaDiff/arrayinterface

Update to ArrayInterface v7

Author: ChrisRackauckas

Project.toml

@@ -5,8 +5,7 @@ version = "1.30.0"
 
 [deps]
 Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"
-ArrayInterfaceCore = "30b0a656-2188-435a-8636-2ec0e6a096e2"
-ArrayInterfaceStaticArrays = "b0d46f97-bff5-4637-a19a-dd75974142cd"
+ArrayInterface = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9"
 Compat = "34da2185-b29b-5c13-b0c7-acf172513d20"
 DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
 FiniteDiff = "6a86dc24-6348-571c-b903-95158fe2bd41"
@@ -20,8 +19,7 @@ VertexSafeGraphs = "19fa3120-7c27-5ec5-8db8-b0b0aa330d6f"
 
 [compat]
 Adapt = "1, 2.0, 3.0"
-ArrayInterfaceCore = "0.1.1"
-ArrayInterfaceStaticArrays = "0.1"
+ArrayInterface = "7"
 Compat = "2.2, 3, 4"
 DataStructures = "0.17, 0.18"
 FiniteDiff = "2.8.1"

README.md

@@ -350,15 +350,4 @@ HesVecGrad(g,x::AbstractArray;autodiff=false)
 These all have the same interface, where `J*v` utilizes the out-of-place
 Jacobian-vector or Hessian-vector function, whereas `mul!(res,J,v)` utilizes
 the appropriate in-place versions. To update the location of differentiation
-in the operator, simply mutate the vector `u`: `J.u .= ...`.
-
-# Note about sparse differentiation of GPUArrays, BandedMatrices, and BlockBandedMatrices
-
-These two matrix types need the dependencies ArrayInterfaceBandedMatrices.jl and
-ArrayInterfaceBlockBandedMatrices.jl to basically work with any functionality
-(anywhere). For now, the right thing to do is to add these libraries and do
-`import` on them if you are using BandedMatrices.jl or BlockBandedMatrices.jl
-for sparsity patterns. In the future, those two packages should just depend on
-ArrayInterface.jl and remove this issue entirely from the user space.
-
-Additionally, GPUs need ArrayInterfaceGPUArrays for proper determination of the indexing.
+in the operator, simply mutate the vector `u`: `J.u .= ...`.

src/SparseDiffTools.jl

@@ -10,14 +10,14 @@ using VertexSafeGraphs
 using Adapt
 
 using LinearAlgebra
-using SparseArrays, ArrayInterfaceCore
+using SparseArrays, ArrayInterface
 
-import StaticArrays, ArrayInterfaceStaticArrays
+import StaticArrays
 
 using ForwardDiff: Dual, jacobian, partials, DEFAULT_CHUNK_THRESHOLD
 using DataStructures: DisjointSets, find_root!, union!
 
-using ArrayInterfaceCore: matrix_colors
+using ArrayInterface: matrix_colors
 
 export contract_color,
        greedy_d1,

src/coloring/high_level.jl

@@ -1,4 +1,4 @@
-abstract type SparseDiffToolsColoringAlgorithm <: ArrayInterfaceCore.ColoringAlgorithm end
+abstract type SparseDiffToolsColoringAlgorithm <: ArrayInterface.ColoringAlgorithm end
 struct GreedyD1Color <: SparseDiffToolsColoringAlgorithm end
 struct BacktrackingColor <: SparseDiffToolsColoringAlgorithm end
 struct ContractionColor <: SparseDiffToolsColoringAlgorithm end
@@ -16,7 +16,7 @@ The coloring defaults to a greedy distance-1 coloring.
 Note that if A isa SparseMatrixCSC, the sparsity pattern is defined by structural nonzeroes,
 ie includes explicitly stored zeros.
 """
-function ArrayInterfaceCore.matrix_colors(A::AbstractMatrix,
+function ArrayInterface.matrix_colors(A::AbstractMatrix,
                                           alg::SparseDiffToolsColoringAlgorithm = GreedyD1Color();
                                           partition_by_rows::Bool = false)
     _A = A isa SparseMatrixCSC ? A : sparse(A) # Avoid the copy

src/differentiation/compute_jacobian_ad.jl

@@ -44,14 +44,14 @@ function ForwardColorJacCache(f::F, x, _chunksize = nothing;
         p = adapt.(parameterless_type(x), generate_chunked_partials(x, colorvec, chunksize))
         _t = Dual{T, eltype(x), getsize(chunksize)
                   }.(vec(x), ForwardDiff.Partials.(first(p)))
-        t = ArrayInterfaceCore.restructure(x, _t)
+        t = ArrayInterface.restructure(x, _t)
     end
 
     if dx isa Nothing
         fx = similar(t)
         _dx = similar(x)
     else
-        tup = ArrayInterfaceCore.allowed_getindex(ArrayInterfaceCore.allowed_getindex(p, 1),
+        tup = ArrayInterface.allowed_getindex(ArrayInterface.allowed_getindex(p, 1),
                                                   1) .* false
         _pi = adapt(parameterless_type(dx), [tup for i in 1:length(dx)])
         fx = reshape(Dual{T, eltype(dx), length(tup)}.(vec(dx), ForwardDiff.Partials.(_pi)),
@@ -156,8 +156,8 @@ end
 function forwarddiff_color_jacobian(f::F, x::AbstractArray{<:Number},
                                     jac_cache::ForwardColorJacCache,
                                     jac_prototype = nothing) where {F}
-    if jac_prototype isa Nothing ? ArrayInterfaceCore.ismutable(x) :
-       ArrayInterfaceCore.ismutable(jac_prototype)
+    if jac_prototype isa Nothing ? ArrayInterface.ismutable(x) :
+       ArrayInterface.ismutable(jac_prototype)
         # Whenever J is mutable, we mutate it to avoid allocations
         dx = jac_cache.dx
         vecx = vec(x)
@@ -190,7 +190,7 @@ function forwarddiff_color_jacobian(J::AbstractMatrix{<:Number}, f::F,
     nrows, ncols = size(J)
 
     if !(sparsity isa Nothing)
-        rows_index, cols_index = ArrayInterfaceCore.findstructralnz(sparsity)
+        rows_index, cols_index = ArrayInterface.findstructralnz(sparsity)
         rows_index = [rows_index[i] for i in 1:length(rows_index)]
         cols_index = [cols_index[i] for i in 1:length(cols_index)]
     end
@@ -267,7 +267,7 @@ function forwarddiff_color_jacobian_immutable(f, x::AbstractArray{<:Number},
     nrows, ncols = size(J)
 
     if !(sparsity isa Nothing)
-        rows_index, cols_index = ArrayInterfaceCore.findstructralnz(sparsity)
+        rows_index, cols_index = ArrayInterface.findstructralnz(sparsity)
         rows_index = [rows_index[i] for i in 1:length(rows_index)]
         cols_index = [cols_index[i] for i in 1:length(cols_index)]
     end
@@ -317,7 +317,7 @@ function forwarddiff_color_jacobian!(J::AbstractMatrix{<:Number},
                                      x::AbstractArray{<:Number};
                                      dx = similar(x, size(J, 1)),
                                      colorvec = 1:length(x),
-                                     sparsity = ArrayInterfaceCore.has_sparsestruct(J) ? J :
+                                     sparsity = ArrayInterface.has_sparsestruct(J) ? J :
                                                 nothing)
     forwarddiff_color_jacobian!(J, f, x,
                                 ForwardColorJacCache(f, x, dx = dx, colorvec = colorvec,
@@ -347,7 +347,7 @@ function forwarddiff_color_jacobian!(J::AbstractMatrix{<:Number},
     end
 
     if FiniteDiff._use_findstructralnz(sparsity)
-        rows_index, cols_index = ArrayInterfaceCore.findstructralnz(sparsity)
+        rows_index, cols_index = ArrayInterface.findstructralnz(sparsity)
     else
         rows_index = 1:size(J, 1)
         cols_index = 1:size(J, 2)
@@ -385,7 +385,7 @@ function forwarddiff_color_jacobian!(J::AbstractMatrix{<:Number},
                     dx .= partials.(fx, j)
                 end
 
-                if ArrayInterfaceCore.fast_scalar_indexing(dx)
+                if ArrayInterface.fast_scalar_indexing(dx)
                     #dx is implicitly used in vecdx
                     if sparseCSC_common_sparsity
                         FiniteDiff._colorediteration!(J, vecdx, colorvec, color_i, ncols)