change dim arguments for diff and unique to keyword args (#26776)

base/deprecated.jl

@@ -1368,6 +1368,9 @@ export readandwrite
 
 @deprecate squeeze(A, dims) squeeze(A, dims=dims)
 
+@deprecate diff(A::AbstractMatrix, dim::Integer) diff(A, dims=dim)
+@deprecate unique(A::AbstractArray, dim::Int) unique(A, dims=dim)
+
 # PR #25196
 @deprecate_binding ObjectIdDict IdDict{Any,Any}
 
@@ -1528,7 +1531,8 @@ end
 @deprecate(matchall(r::Regex, s::AbstractString; overlap::Bool = false),
  collect(m.match for m in eachmatch(r, s, overlap = overlap)))
 
-@deprecate diff(A::AbstractMatrix) diff(A, 1)
+# remove depwarn for `diff` in multidimensional.jl
+# @deprecate diff(A::AbstractMatrix) diff(A, dims=1)
 
 # PR 26194
 export assert

base/multidimensional.jl

@@ -1083,10 +1083,10 @@ diff(a::AbstractVector) = [ a[i+1] - a[i] for i=1:length(a)-1 ]
 
 """
  diff(A::AbstractVector)
- diff(A::AbstractMatrix, dim::Integer)
+ diff(A::AbstractMatrix; dims::Integer)
 
 Finite difference operator of matrix or vector `A`. If `A` is a matrix,
-specify the dimension over which to operate with the `dim` argument.
+specify the dimension over which to operate with the `dims` keyword argument.
 
 # Examples
 ```jldoctest
@@ -1095,7 +1095,7 @@ julia> a = [2 4; 6 16]
  2 4
  6 16
 
-julia> diff(a,2)
+julia> diff(a, dims=2)
 2×1 Array{Int64,2}:
  2
  10
@@ -1107,13 +1107,17 @@ julia> diff(vec(a))
  12
 ```
 """
-function diff(A::AbstractMatrix, dim::Integer)
- if dim == 1
+function diff(A::AbstractMatrix; dims::Union{Integer,Nothing}=nothing)
+ if dims === nothing
+ depwarn("`diff(A::AbstractMatrix)` is deprecated, use `diff(A, dims=1)` instead.", :diff)
+ dims = 1
+ end
+ if dims == 1
  [A[i+1,j] - A[i,j] for i=1:size(A,1)-1, j=1:size(A,2)]
- elseif dim == 2
+ elseif dims == 2
  [A[i,j+1] - A[i,j] for i=1:size(A,1), j=1:size(A,2)-1]
  else
- throw(ArgumentError("dimension dim must be 1 or 2, got $dim"))
+ throw(ArgumentError("dimension must be 1 or 2, got $dims"))
  end
 end
 
@@ -1724,9 +1728,9 @@ end
 hash(x::Prehashed) = x.hash
 
 """
- unique(A::AbstractArray, dim::Int)
+ unique(A::AbstractArray; dims::Int)
 
-Return unique regions of `A` along dimension `dim`.
+Return unique regions of `A` along dimension `dims`.
 
 # Examples
 ```jldoctest
@@ -1745,7 +1749,7 @@ julia> unique(A)
  true
  false
 
-julia> unique(A, 2)
+julia> unique(A, dims=2)
 2×1×2 Array{Bool,3}:
 [:, :, 1] =
  true
@@ -1755,14 +1759,18 @@ julia> unique(A, 2)
  true
  false
 
-julia> unique(A, 3)
+julia> unique(A, dims=3)
 2×2×1 Array{Bool,3}:
 [:, :, 1] =
  true true
  false false
 ```
 """
-@generated function unique(A::AbstractArray{T,N}, dim::Int) where {T,N}
+unique(A::AbstractArray; dims::Union{Colon,Integer} = :) = _unique_dims(A, dims)
+
+_unique_dims(A::AbstractArray, dims::Colon) = invoke(unique, Tuple{Any}, A)
+
+@generated function _unique_dims(A::AbstractArray{T,N}, dim::Integer) where {T,N}
  inds = inds -> zeros(UInt, inds)
  quote
  1 <= dim <= $N || return copy(A)

stdlib/LinearAlgebra/test/lapack.jl

@@ -202,7 +202,7 @@ end
  Bvs = eigvecs(B)
  Avs = eigvecs(A)
  Bvs = LAPACK.gebak!('S','R',ilo,ihi,scale,Bvs)
- @test norm(diff(Avs ./ Bvs, 1)) < 100 * eps(abs(float(one(elty))))
+ @test norm(diff(Avs ./ Bvs, dims=1)) < 100 * eps(abs(float(one(elty))))
  end
 end
 

stdlib/SparseArrays/src/deprecated.jl

@@ -233,6 +233,7 @@ Base.@deprecate_binding blkdiag blockdiag
 @deprecate complex(x::AbstractVector{<:Real}, y::AbstractSparseVector{<:Real}) complex.(x, y)
 @deprecate complex(x::AbstractSparseVector{<:Real}, y::AbstractVector{<:Real}) complex.(x, y)
 
+@deprecate diff(a::SparseMatrixCSC, dim::Integer) diff(a, dims=dim)
 
 # END 0.7 deprecations
 

stdlib/SparseArrays/src/linalg.jl

@@ -526,7 +526,7 @@ function sparse_diff2(a::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti}
  return SparseMatrixCSC(m, n-1, colptr, rowval, nzval)
 end
 
-diff(a::SparseMatrixCSC, dim::Integer)= dim==1 ? sparse_diff1(a) : sparse_diff2(a)
+diff(a::SparseMatrixCSC; dims::Integer) = dims==1 ? sparse_diff1(a) : sparse_diff2(a)
 
 ## norm and rank
 vecnorm(A::SparseMatrixCSC, p::Real=2) = vecnorm(view(A.nzval, 1:nnz(A)), p)

stdlib/SparseArrays/test/sparse.jl

@@ -569,13 +569,13 @@ end
 
 @testset "issue #5853, sparse diff" begin
  for i=1:2, a=Any[[1 2 3], reshape([1, 2, 3],(3,1)), Matrix(1.0I, 3, 3)]
- @test all(diff(sparse(a),i) == diff(a,i))
+ @test all(diff(sparse(a),dims=i) == diff(a,dims=i))
  end
 end
 
 @testset "access to undefined error types that initially allocate elements as #undef" begin
  @test all(sparse(1:2, 1:2, Number[1,2])^2 == sparse(1:2, 1:2, [1,4]))
- sd1 = diff(sparse([1,1,1], [1,2,3], Number[1,2,3]), 1)
+ sd1 = diff(sparse([1,1,1], [1,2,3], Number[1,2,3]), dims=1)
 end
 
 @testset "issue #6036" begin

test/arrayops.jl

@@ -618,23 +618,23 @@ Base.hash(::HashCollision, h::UInt) = h
 let A, B, C, D
  A = fill(1., 10, 10)
  A[diagind(A)] = shuffle!([1:10;])
- @test unique(A, 1) == A
- @test unique(A, 2) == A
+ @test unique(A, dims=1) == A
+ @test unique(A, dims=2) == A
 
  # 10 repeats of each row
  B = A[shuffle!(repeat(1:10, 10)), :]
- C = unique(B, 1)
+ C = unique(B, dims=1)
  @test sortrows(C) == sortrows(A)
- @test unique(B, 2) == B
- @test unique(B', 2)' == C
+ @test unique(B, dims=2) == B
+ @test unique(B', dims=2)' == C
 
  # Along third dimension
  D = cat(3, B, B)
- @test unique(D, 1) == cat(3, C, C)
- @test unique(D, 3) == cat(3, B)
+ @test unique(D, dims=1) == cat(3, C, C)
+ @test unique(D, dims=3) == cat(3, B)
 
  # With hash collisions
- @test map(x -> x.x, unique(map(HashCollision, B), 1)) == C
+ @test map(x -> x.x, unique(map(HashCollision, B), dims=1)) == C
 end
 
 @testset "large matrices transpose" begin
@@ -2216,14 +2216,14 @@ end
  X = [3 9 5;
  7 4 2;
  2 1 10]
- @test diff(X,1) == [4 -5 -3; -5 -3 8]
- @test diff(X,2) == [6 -4; -3 -2; -1 9]
- @test diff(view(X, 1:2, 1:2),1) == [4 -5]
- @test diff(view(X, 1:2, 1:2),2) == reshape([6; -3], (2,1))
- @test diff(view(X, 2:3, 2:3),1) == [-3 8]
- @test diff(view(X, 2:3, 2:3),2) == reshape([-2; 9], (2,1))
- @test_throws ArgumentError diff(X,3)
- @test_throws ArgumentError diff(X,-1)
+ @test diff(X,dims=1) == [4 -5 -3; -5 -3 8]
+ @test diff(X,dims=2) == [6 -4; -3 -2; -1 9]
+ @test diff(view(X, 1:2, 1:2),dims=1) == [4 -5]
+ @test diff(view(X, 1:2, 1:2),dims=2) == reshape([6; -3], (2,1))
+ @test diff(view(X, 2:3, 2:3),dims=1) == [-3 8]
+ @test diff(view(X, 2:3, 2:3),dims=2) == reshape([-2; 9], (2,1))
+ @test_throws ArgumentError diff(X,dims=3)
+ @test_throws ArgumentError diff(X,dims=-1)
 end
 
 @testset "accumulate, accumulate!" begin

test/bitarray.jl

@@ -1412,8 +1412,8 @@ timesofar("cat")
  @check_bit_operation diff(b1) Vector{Int}
 
  b1 = bitrand(n1, n2)
- @check_bit_operation diff(b1, 1) Matrix{Int}
- @check_bit_operation diff(b1, 2) Matrix{Int}
+ @check_bit_operation diff(b1, dims=1) Matrix{Int}
+ @check_bit_operation diff(b1, dims=2) Matrix{Int}
 
  b1 = bitrand(n1, n1)
  @check_bit_operation svd(b1)

test/offsetarray.jl

@@ -406,8 +406,8 @@ seek(io, 0)
 amin, amax = extrema(parent(A))
 @test clamp.(A, (amax+amin)/2, amax).parent == clamp.(parent(A), (amax+amin)/2, amax)
 
-@test unique(A, 1) == parent(A)
-@test unique(A, 2) == parent(A)
+@test unique(A, dims=1) == parent(A)
+@test unique(A, dims=2) == parent(A)
 v = OffsetArray(rand(8), (-2,))
 @test sort(v) == OffsetArray(sort(parent(v)), v.offsets)
 @test sortrows(A) == OffsetArray(sortrows(parent(A)), A.offsets)