Deprecate +/- methods for array+scalar etc

NEWS.md

@@ -431,6 +431,10 @@ Deprecated or removed
   * `map` on dictionaries previously operated on `key=>value` pairs. This behavior is deprecated,
     and in the future `map` will operate only on values ([#5794]).
 
+  * Automatically broadcasted `+` and `-` for `array + scalar`, `scalar - array`, and so-on have
+    been deprecated due to inconsistency with linear algebra. Use `.+` and `.-` for these operations
+    instead.
+
 Command-line option changes
 ---------------------------
 

base/abstractarray.jl

@@ -1258,7 +1258,7 @@ function _cat(A, shape::NTuple{N}, catdims, X...) where N
     for x in X
         for i = 1:N
             if concat[i]
-                inds[i] = offsets[i] + cat_indices(x, i)
+                inds[i] = offsets[i] .+ cat_indices(x, i)
                 offsets[i] += cat_size(x, i)
             else
                 inds[i] = 1:shape[i]

base/abstractarraymath.jl

@@ -438,7 +438,7 @@ _reperr(s, n, N) = throw(ArgumentError("number of " * s * " repetitions " *
         for c in CartesianRange(indices(A))
             for i in 1:ndims(A)
                 n = inner[i]
-                inner_indices[i] = (1:n) + ((c[i] - 1) * n)
+                inner_indices[i] = (1:n) .+ ((c[i] - 1) * n)
             end
             fill!(view(R, inner_indices...), A[c])
         end
@@ -453,7 +453,7 @@ _reperr(s, n, N) = throw(ArgumentError("number of " * s * " repetitions " *
     for i in 1:length(outer)
         B = view(R, src_indices...)
         for j in 2:outer[i]
-            dest_indices[i] += inner_shape[i]
+            dest_indices[i] = dest_indices[i] .+ inner_shape[i]
             R[dest_indices...] = B
         end
         src_indices[i] = dest_indices[i] = 1:shape[i]

base/arraymath.jl

@@ -40,7 +40,7 @@ for f in (:+, :-)
     end
 end
 
-for f in (:/, :\, :*, :+, :-)
+for f in (:/, :\, :*)
     if f != :/
         @eval ($f)(A::Number, B::AbstractArray) = broadcast($f, A, B)
     end

base/dates/periods.jl

@@ -358,8 +358,6 @@ GeneralPeriod = Union{Period, CompoundPeriod}
 
 for op in (:+, :-)
     @eval begin
-        ($op)(x::GeneralPeriod, Y::StridedArray{<:GeneralPeriod}) = broadcast($op, x, Y)
-        ($op)(Y::StridedArray{<:GeneralPeriod}, x::GeneralPeriod) = broadcast($op, Y, x)
         ($op)(X::StridedArray{<:GeneralPeriod}, Y::StridedArray{<:GeneralPeriod}) =
             reshape(CompoundPeriod[($op)(x, y) for (x, y) in zip(X, Y)], promote_shape(size(X), size(Y)))
     end

base/deprecated.jl

@@ -1766,6 +1766,17 @@ import .Iterators.enumerate
 # issue #5794
 @deprecate map(f, d::T) where {T<:Associative}  T( f(p) for p in pairs(d) )
 
+# PR #22932
+@deprecate +(a::Number, b::AbstractArray) broadcast(+, a, b)
+@deprecate +(a::AbstractArray, b::Number) broadcast(+, a, b)
+@deprecate -(a::Number, b::AbstractArray) broadcast(-, a, b)
+@deprecate -(a::AbstractArray, b::Number) broadcast(-, a, b)
+
+@deprecate +(a::Dates.GeneralPeriod, b::StridedArray{<:Dates.GeneralPeriod}) broadcast(+, a, b)
+@deprecate +(a::StridedArray{<:Dates.GeneralPeriod}, b::Dates.GeneralPeriod) broadcast(+, a, b)
+@deprecate -(a::Dates.GeneralPeriod, b::StridedArray{<:Dates.GeneralPeriod}) broadcast(-, a, b)
+@deprecate -(a::StridedArray{<:Dates.GeneralPeriod}, b::Dates.GeneralPeriod) broadcast(-, a, b)
+
 # END 0.7 deprecations
 
 # BEGIN 1.0 deprecations

base/gmp.jl

@@ -613,7 +613,7 @@ function base(b::Integer, n::BigInt, pad::Integer=1)
     nd  = max(nd1, pad)
     sv  = Base.StringVector(nd + isneg(n))
     MPZ.get_str!(pointer(sv) + nd - nd1, b, n)
-    @inbounds for i = (1:nd-nd1) + isneg(n)
+    @inbounds for i = (1:nd-nd1) .+ isneg(n)
         sv[i] = '0' % UInt8
     end
     isneg(n) && (sv[1] = '-' % UInt8)

base/linalg/arpack.jl

@@ -51,8 +51,8 @@ function aupd_wrapper(T, matvecA!::Function, matvecB::Function, solveSI::Functio
             throw(ARPACKException(info[]))
         end
 
-        x = view(workd, ipntr[1]+zernm1)
-        y = view(workd, ipntr[2]+zernm1)
+        x = view(workd, ipntr[1] .+ zernm1)
+        y = view(workd, ipntr[2] .+ zernm1)
         if mode == 1  # corresponds to dsdrv1, dndrv1 or zndrv1
             if ido[] == 1
                 matvecA!(y, x)
@@ -87,7 +87,7 @@ function aupd_wrapper(T, matvecA!::Function, matvecB::Function, solveSI::Functio
             if ido[] == -1
                 y[:] = solveSI(matvecB(x))
             elseif  ido[] == 1
-                y[:] = solveSI(view(workd,ipntr[3]+zernm1))
+                y[:] = solveSI(view(workd,ipntr[3] .+ zernm1))
             elseif ido[] == 2
                 y[:] = matvecB(x)
             elseif ido[] == 99

base/linalg/bitarray.jl

@@ -120,10 +120,10 @@ function kron(a::BitMatrix, b::BitMatrix)
     R = falses(mA*mB, nA*nB)
 
     for i = 1:mA
-        ri = (1:mB)+(i-1)*mB
+        ri = (1:mB) .+ ((i-1)*mB)
         for j = 1:nA
             if a[i,j]
-                rj = (1:nB)+(j-1)*nB
+                rj = (1:nB) .+ ((j-1)*nB)
                 R[ri,rj] = b
             end
         end

base/linalg/symmetric.jl

@@ -321,7 +321,7 @@ A_mul_Bt(A::AbstractTriangular, B::RealHermSymComplexSym) = A*B
 Ac_mul_B(A::RealHermSymComplexHerm, B::AbstractTriangular) = A*B
 A_mul_Bc(A::AbstractTriangular, B::RealHermSymComplexHerm) = A*B
 
-for T in (:Symmetric, :Hermitian), op in (:+, :-, :*, :/)
+for T in (:Symmetric, :Hermitian), op in (:*, :/)
     # Deal with an ambiguous case
     @eval ($op)(A::$T, x::Bool) = ($T)(($op)(A.data, x), Symbol(A.uplo))
     S = T == :Hermitian ? :Real : :Number

base/linalg/transpose.jl

@@ -63,8 +63,8 @@ end
 function transposeblock!(f, B::AbstractMatrix, A::AbstractMatrix, m::Int, n::Int, offseti::Int, offsetj::Int)
     if m*n<=transposebaselength
         @inbounds begin
-            for j = offsetj+(1:n)
-                for i = offseti+(1:m)
+            for j = offsetj .+ (1:n)
+                for i = offseti .+ (1:m)
                     B[j,i] = f(A[i,j])
                 end
             end

base/multidimensional.jl

@@ -1144,7 +1144,7 @@ end
 @inline unchecked_bool_convert(x::Real) = x == 1
 
 function copy_to_bitarray_chunks!(Bc::Vector{UInt64}, pos_d::Int, C::StridedArray{<:Real}, pos_s::Int, numbits::Int)
-    @inbounds for i = (1:numbits) + pos_s - 1
+    @inbounds for i = (1:numbits) .+ (pos_s - 1)
         try_bool_conversion(C[i])
     end
 

base/range.jl

@@ -741,43 +741,67 @@ end
     StepRangeLen{T,R,S}(-r.ref, -r.step, length(r), r.offset)
 -(r::LinSpace) = LinSpace(-r.start, -r.stop, length(r))
 
-+(x::Real, r::AbstractUnitRange) = range(x + first(r), length(r))
+*(x::Number, r::AbstractRange) = range(x*first(r), x*step(r), length(r))
+*(x::Number, r::StepRangeLen{T}) where {T} =
+    StepRangeLen{typeof(x*T(r.ref))}(x*r.ref, x*r.step, length(r), r.offset)
+*(x::Number, r::LinSpace) = LinSpace(x * r.start, x * r.stop, r.len)
+# separate in case of noncommutative multiplication
+*(r::AbstractRange, x::Number) = range(first(r)*x, step(r)*x, length(r))
+*(r::StepRangeLen{T}, x::Number) where {T} =
+    StepRangeLen{typeof(T(r.ref)*x)}(r.ref*x, r.step*x, length(r), r.offset)
+*(r::LinSpace, x::Number) = LinSpace(r.start * x, r.stop * x, r.len)
+
+/(r::AbstractRange, x::Number) = range(first(r)/x, step(r)/x, length(r))
+/(r::StepRangeLen{T}, x::Number) where {T} =
+    StepRangeLen{typeof(T(r.ref)/x)}(r.ref/x, r.step/x, length(r), r.offset)
+/(r::LinSpace, x::Number) = LinSpace(r.start / x, r.stop / x, r.len)
+# also, separate in case of noncommutative multiplication (division)
+\(x::Number, r::AbstractRange) = range(x\first(r), x\step(r), x\length(r))
+\(x::Number, r::StepRangeLen) = StepRangeLen(x\r.ref, x\r.step, length(r), r.offset)
+\(x::Number, r::LinSpace) = LinSpace(x \ r.start, x \ r.stop, r.len)
+
+## scalar-range broadcast operations ##
+
+broadcast(::typeof(-), r::OrdinalRange) = range(-first(r), -step(r), length(r))
+broadcast(::typeof(-), r::StepRangeLen) = StepRangeLen(-r.ref, -r.step, length(r), r.offset)
+broadcast(::typeof(-), r::LinSpace) = LinSpace(-r.start, -r.stop, length(r))
+
+broadcast(::typeof(+), x::Real, r::AbstractUnitRange) = range(x + first(r), length(r))
 # For #18336 we need to prevent promotion of the step type:
-+(x::Number, r::AbstractUnitRange) = range(x + first(r), step(r), length(r))
-+(x::Number, r::AbstractRange) = (x+first(r)):step(r):(x+last(r))
-function +(x::Number, r::StepRangeLen{T}) where T
+broadcast(::typeof(+), x::Number, r::AbstractUnitRange) = range(x + first(r), step(r), length(r))
+broadcast(::typeof(+), x::Number, r::AbstractRange) = (x+first(r)):step(r):(x+last(r))
+function broadcast(::typeof(+), x::Number, r::StepRangeLen{T}) where T
     newref = x + r.ref
     StepRangeLen{typeof(T(r.ref) + x)}(newref, r.step, length(r), r.offset)
 end
-function +(x::Number, r::LinSpace)
+function broadcast(::typeof(+), x::Number, r::LinSpace)
     LinSpace(x + r.start, x + r.stop, r.len)
 end
-+(r::AbstractRange, x::Number) = x + r  # assumes addition is commutative
+broadcast(::typeof(+), r::AbstractRange, x::Number) = broadcast(+, x, r)  # assumes addition is commutative
 
--(x::Number, r::AbstractRange)      = (x-first(r)):-step(r):(x-last(r))
--(x::Number, r::StepRangeLen) = +(x, -r)
-function -(x::Number, r::LinSpace)
+broadcast(::typeof(-), x::Number, r::AbstractRange) = (x-first(r)):-step(r):(x-last(r))
+broadcast(::typeof(-), x::Number, r::StepRangeLen) = broadcast(+, x, -r)
+function broadcast(::typeof(-), x::Number, r::LinSpace)
     LinSpace(x - r.start, x - r.stop, r.len)
 end
 
--(r::AbstractRange, x::Number) = +(-x, r)
+broadcast(::typeof(-), r::AbstractRange, x::Number) = broadcast(+, -x, r)  # assumes addition is commutative
 
-*(x::Number, r::AbstractRange)        = range(x*first(r), x*step(r), length(r))
-*(x::Number, r::StepRangeLen{T}) where {T} =
-    StepRangeLen{typeof(x*T(r.ref))}(x*r.ref, x*r.step, length(r), r.offset)
-*(x::Number, r::LinSpace)     = LinSpace(x * r.start, x * r.stop, r.len)
+broadcast(::typeof(*), x::Number, r::AbstractRange) = range(x*first(r), x*step(r), length(r))
+broadcast(::typeof(*), x::Number, r::StepRangeLen)  = StepRangeLen(x*r.ref, x*r.step, length(r), r.offset)
+broadcast(::typeof(*), x::Number, r::LinSpace)      = LinSpace(x * r.start, x * r.stop, r.len)
 # separate in case of noncommutative multiplication
-*(r::AbstractRange, x::Number)        = range(first(r)*x, step(r)*x, length(r))
-*(r::StepRangeLen{T}, x::Number) where {T} =
-    StepRangeLen{typeof(T(r.ref)*x)}(r.ref*x, r.step*x, length(r), r.offset)
-*(r::LinSpace, x::Number)     = LinSpace(r.start * x, r.stop * x, r.len)
-
-/(r::AbstractRange, x::Number)        = range(first(r)/x, step(r)/x, length(r))
-/(r::StepRangeLen{T}, x::Number) where {T} =
-    StepRangeLen{typeof(T(r.ref)/x)}(r.ref/x, r.step/x, length(r), r.offset)
-/(r::LinSpace, x::Number)     = LinSpace(r.start / x, r.stop / x, r.len)
-
-/(x::Number, r::AbstractRange) = [ x/y for y=r ]
+broadcast(::typeof(*), r::AbstractRange, x::Number) = range(first(r)*x, step(r)*x, length(r))
+broadcast(::typeof(*), r::StepRangeLen, x::Number)  = StepRangeLen(r.ref*x, r.step*x, length(r), r.offset)
+broadcast(::typeof(*), r::LinSpace, x::Number)      = LinSpace(r.start * x, r.stop * x, r.len)
+
+broadcast(::typeof(/), r::AbstractRange, x::Number) = range(first(r)/x, step(r)/x, length(r))
+broadcast(::typeof(/), r::StepRangeLen, x::Number)  = StepRangeLen(r.ref/x, r.step/x, length(r), r.offset)
+broadcast(::typeof(/), r::LinSpace, x::Number)      = LinSpace(r.start / x, r.stop / x, r.len)
+# also, separate in case of noncommutative multiplication (division)
+broadcast(::typeof(\), x::Number, r::AbstractRange) = range(x\first(r), x\step(r), x\length(r))
+broadcast(::typeof(\), x::Number, r::StepRangeLen)  = StepRangeLen(x\r.ref, x\r.step, length(r), r.offset)
+broadcast(::typeof(\), x::Number, r::LinSpace)      = LinSpace(x \ r.start, x \ r.stop, r.len)
 
 # promote eltype if at least one container wouldn't change, otherwise join container types.
 el_same(::Type{T}, a::Type{<:AbstractArray{T,n}}, b::Type{<:AbstractArray{T,n}}) where {T,n}   = a
@@ -961,3 +985,6 @@ function +(r1::StepRangeLen{T,S}, r2::StepRangeLen{T,S}) where {T,S}
 end
 
 -(r1::StepRangeLen, r2::StepRangeLen) = +(r1, -r2)
+
+broadcast(::typeof(+), r1::AbstractRange, r2::AbstractRange) = r1 + r2
+broadcast(::typeof(-), r1::AbstractRange, r2::AbstractRange) = r1 - r2

base/repl/REPLCompletions.jl

@@ -614,7 +614,7 @@ function shell_completions(string, pos)
         r = first(last_parse):prevind(last_parse, last(last_parse))
         partial = scs[r]
         ret, range = completions(partial, endof(partial))
-        range += first(r) - 1
+        range = range .+ (first(r) - 1)
         return ret, range, true
     end
     return String[], 0:-1, false

base/show.jl

@@ -1653,7 +1653,7 @@ function print_matrix(io::IO, X::AbstractVecOrMat,
                 print(io, i == first(rowsA) ? pre : presp)
                 print_matrix_row(io, X,Lalign,i,colsA[1:length(Lalign)],sep)
                 print(io, (i - first(rowsA)) % hmod == 0 ? hdots : repeat(" ", length(hdots)))
-                print_matrix_row(io, X,Ralign,i,n-length(Ralign)+colsA,sep)
+                print_matrix_row(io, X, Ralign, i, (n - length(Ralign)) .+ colsA, sep)
                 print(io, i == last(rowsA) ? post : postsp)
                 if i != last(rowsA); println(io); end
             end
@@ -1681,7 +1681,7 @@ function print_matrix(io::IO, X::AbstractVecOrMat,
                 print(io, i == first(rowsA) ? pre : presp)
                 print_matrix_row(io, X,Lalign,i,colsA[1:length(Lalign)],sep)
                 print(io, (i - first(rowsA)) % hmod == 0 ? hdots : repeat(" ", length(hdots)))
-                print_matrix_row(io, X,Ralign,i,n-length(Ralign)+colsA,sep)
+                print_matrix_row(io, X,Ralign,i,(n-length(Ralign)).+colsA,sep)
                 print(io, i == last(rowsA) ? post : postsp)
                 if i != rowsA[end] || i == rowsA[halfheight]; println(io); end
                 if i == rowsA[halfheight]

base/sparse/cholmod.jl

@@ -811,7 +811,7 @@ end
 function get_perm(F::Factor)
     s = unsafe_load(pointer(F))
     p = unsafe_wrap(Array, s.Perm, s.n, false)
-    p + 1
+    p .+ 1
 end
 get_perm(FC::FactorComponent) = get_perm(Factor(FC))
 

base/sparse/linalg.jl

@@ -775,7 +775,7 @@ function kron(a::SparseMatrixCSC{Tv,Ti}, b::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti
             stopB = colptrB[i+1]-1
             lB = stopB - startB + 1
 
-            ptr_range = (1:lB) + (colptr[col]-1)
+            ptr_range = (1:lB) .+ (colptr[col]-1)
 
             colptr[col+1] = colptr[col] + lA * lB
             col += 1
@@ -787,7 +787,7 @@ function kron(a::SparseMatrixCSC{Tv,Ti}, b::SparseMatrixCSC{Tv,Ti}) where {Tv,Ti
                     nzval[ptr] = nzvalA[ptrA] * nzvalB[ptrB]
                     ptrB += 1
                 end
-                ptr_range += lB
+                ptr_range = ptr_range .+ lB
             end
         end
     end

base/sparse/sparsematrix.jl

@@ -3115,13 +3115,13 @@ function hcat(X::SparseMatrixCSC...)
     nX_sofar = 0
     @inbounds for i = 1 : num
         XI = X[i]
-        colptr[(1 : nX[i] + 1) + nX_sofar] = XI.colptr .+ nnz_sofar
+        colptr[(1 : nX[i] + 1) .+ nX_sofar] = XI.colptr .+ nnz_sofar
         if nnzX[i] == length(XI.rowval)
-            rowval[(1 : nnzX[i]) + nnz_sofar] = XI.rowval
-            nzval[(1 : nnzX[i]) + nnz_sofar] = XI.nzval
+            rowval[(1 : nnzX[i]) .+ nnz_sofar] = XI.rowval
+            nzval[(1 : nnzX[i]) .+ nnz_sofar] = XI.nzval
         else
-            rowval[(1 : nnzX[i]) + nnz_sofar] = XI.rowval[1:nnzX[i]]
-            nzval[(1 : nnzX[i]) + nnz_sofar] = XI.nzval[1:nnzX[i]]
+            rowval[(1 : nnzX[i]) .+ nnz_sofar] = XI.rowval[1:nnzX[i]]
+            nzval[(1 : nnzX[i]) .+ nnz_sofar] = XI.nzval[1:nnzX[i]]
         end
         nnz_sofar += nnzX[i]
         nX_sofar += nX[i]
@@ -3166,9 +3166,9 @@ function blkdiag(X::SparseMatrixCSC...)
     nX_sofar = 0
     mX_sofar = 0
     for i = 1 : num
-        colptr[(1 : nX[i] + 1) + nX_sofar] = X[i].colptr .+ nnz_sofar
-        rowval[(1 : nnzX[i]) + nnz_sofar] = X[i].rowval .+ mX_sofar
-        nzval[(1 : nnzX[i]) + nnz_sofar] = X[i].nzval
+        colptr[(1 : nX[i] + 1) .+ nX_sofar] = X[i].colptr .+ nnz_sofar
+        rowval[(1 : nnzX[i]) .+ nnz_sofar] = X[i].rowval .+ mX_sofar
+        nzval[(1 : nnzX[i]) .+ nnz_sofar] = X[i].nzval
         nnz_sofar += nnzX[i]
         nX_sofar += nX[i]
         mX_sofar += mX[i]

base/sparse/sparsevector.jl

@@ -994,7 +994,7 @@ function hvcat(rows::Tuple{Vararg{Int}}, X::_SparseConcatGroup...)
     tmp_rows = Vector{SparseMatrixCSC}(nbr)
     k = 0
     @inbounds for i = 1 : nbr
-        tmp_rows[i] = hcat(X[(1 : rows[i]) + k]...)
+        tmp_rows[i] = hcat(X[(1 : rows[i]) .+ k]...)
         k += rows[i]
     end
     vcat(tmp_rows...)
@@ -1827,7 +1827,7 @@ for isunittri in (true, false), islowertri in (true, false)
                 nzrange = $( (islowertri && !istrans) || (!islowertri && istrans) ?
                     :(b.nzind[1]:b.n) :
                     :(1:b.nzind[end]) )
-                nzrangeviewbnz = view(b.nzval, nzrange - b.nzind[1] + 1)
+                nzrangeviewbnz = view(b.nzval, nzrange .- (b.nzind[1] - 1))
                 nzrangeviewA = $tritype(view(A.data, nzrange, nzrange))
                 ($func)(nzrangeviewA, nzrangeviewbnz)
                 # could strip any miraculous zeros here perhaps
@@ -1892,7 +1892,7 @@ function sort(x::SparseVector{Tv,Ti}; kws...) where {Tv,Ti}
     n,k = length(x),length(allvals)
     z = findfirst(sinds,k)
     newnzind = collect(Ti,1:k-1)
-    newnzind[z:end]+= n-k+1
+    newnzind[z:end] .+= n-k+1
     newnzvals = allvals[deleteat!(sinds[1:k],z)]
     SparseVector(n,newnzind,newnzvals)
 end

test/TestHelpers.jl

@@ -147,9 +147,9 @@ Base.eachindex(::IndexLinear, A::OffsetVector) = indices(A, 1)
 # Implementations of indices and indices1. Since bounds-checking is
 # performance-critical and relies on indices, these are usually worth
 # optimizing thoroughly.
-@inline Base.indices(A::OffsetArray, d) = 1 <= d <= length(A.offsets) ? indices(parent(A))[d] + A.offsets[d] : (1:1)
+@inline Base.indices(A::OffsetArray, d) = 1 <= d <= length(A.offsets) ? indices(parent(A))[d] .+ A.offsets[d] : (1:1)
 @inline Base.indices(A::OffsetArray) = _indices(indices(parent(A)), A.offsets)  # would rather use ntuple, but see #15276
-@inline _indices(inds, offsets) = (inds[1]+offsets[1], _indices(tail(inds), tail(offsets))...)
+@inline _indices(inds, offsets) = (inds[1] .+ offsets[1], _indices(tail(inds), tail(offsets))...)
 _indices(::Tuple{}, ::Tuple{}) = ()
 Base.indices1(A::OffsetArray{T,0}) where {T} = 1:1  # we only need to specialize this one