Deprecate A[ct]_(mul|ldiv|rdiv)_B[ct][!] in favor f *, /, \, mul!, ldiv!, and rdiv!.

Author: Sacha0

base/deprecated.jl

@@ -220,34 +220,6 @@ export
     :,
     =>,
     ∘,
-    A_ldiv_B!,
-    A_ldiv_Bc,
-    A_ldiv_Bt,
-    A_mul_B!,
-    A_mul_Bc,
-    A_mul_Bc!,
-    A_mul_Bt,
-    A_mul_Bt!,
-    A_rdiv_Bc,
-    A_rdiv_Bt,
-    Ac_ldiv_B,
-    Ac_ldiv_B!,
-    Ac_ldiv_Bc,
-    Ac_mul_B,
-    Ac_mul_B!,
-    Ac_mul_Bc,
-    Ac_mul_Bc!,
-    Ac_rdiv_B,
-    Ac_rdiv_Bc,
-    At_ldiv_B,
-    At_ldiv_B!,
-    At_ldiv_Bt,
-    At_mul_B,
-    At_mul_B!,
-    At_mul_Bt,
-    At_mul_Bt!,
-    At_rdiv_B,
-    At_rdiv_Bt,
 
 # scalar math
     @evalpoly,

base/exports.jl

@@ -1,26 +1,5 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-# shims to maintain existence of names in Base module in A_mul_B deprecation process
-function Ac_ldiv_Bt end
-function At_ldiv_Bt end
-function A_ldiv_Bt end
-function At_ldiv_B end
-function Ac_ldiv_Bc end
-function A_ldiv_Bc end
-function Ac_ldiv_B end
-function At_rdiv_Bt end
-function A_rdiv_Bt end
-function At_rdiv_B end
-function Ac_rdiv_Bc end
-function A_rdiv_Bc end
-function Ac_rdiv_B end
-function At_mul_Bt end
-function A_mul_Bt end
-function At_mul_B end
-function Ac_mul_Bc end
-function A_mul_Bc end
-function Ac_mul_B end
-
 """
 Linear algebra module. Provides array arithmetic,
 matrix factorizations and other linear algebra related
@@ -29,8 +8,6 @@ functionality.
 module LinAlg
 
 import Base: \, /, *, ^, +, -, ==
-import Base: A_mul_Bt, At_ldiv_Bt, A_rdiv_Bc, At_ldiv_B, Ac_mul_Bc, A_mul_Bc, Ac_mul_B,
-    Ac_ldiv_B, Ac_ldiv_Bc, At_mul_Bt, A_rdiv_Bt, At_mul_B
 import Base: USE_BLAS64, abs, acos, acosh, acot, acoth, acsc, acsch, adjoint, asec, asech,
     asin, asinh, atan, atanh, axes, big, broadcast, ceil, conj, convert, copy, copyto!, cos,
     cosh, cot, coth, csc, csch, eltype, exp, findmax, findmin, fill!, floor, getindex, hcat,
@@ -171,34 +148,6 @@ export
 # Operators
     \,
     /,
-    A_ldiv_B!,
-    A_ldiv_Bc,
-    A_ldiv_Bt,
-    A_mul_B!,
-    A_mul_Bc,
-    A_mul_Bc!,
-    A_mul_Bt,
-    A_mul_Bt!,
-    A_rdiv_Bc,
-    A_rdiv_Bt,
-    Ac_ldiv_B,
-    Ac_ldiv_Bc,
-    Ac_ldiv_B!,
-    Ac_mul_B,
-    Ac_mul_B!,
-    Ac_mul_Bc,
-    Ac_mul_Bc!,
-    Ac_rdiv_B,
-    Ac_rdiv_Bc,
-    At_ldiv_B,
-    At_ldiv_Bt,
-    At_ldiv_B!,
-    At_mul_B,
-    At_mul_B!,
-    At_mul_Bt,
-    At_mul_Bt!,
-    At_rdiv_B,
-    At_rdiv_Bt,
 
 # Constants
     I
@@ -261,16 +210,37 @@ function char_uplo(uplo::Symbol)
     end
 end
 
-# shims to maintain existence of names in LinAlg module in A_mul_B deprecation process
-function A_mul_B! end
-function Ac_mul_B! end
-function Ac_mul_B! end
-function At_mul_B! end
-function A_ldiv_B! end
-function At_ldiv_B! end
-function Ac_ldiv_B! end
-function A_rdiv_B! end
-function A_rdiv_Bc! end
+"""
+    ldiv!([Y,] A, B) -> Y
+
+Compute `A \\ B` in-place and store the result in `Y`, returning the result.
+If only two arguments are passed, then `ldiv!(A, B)` overwrites `B` with
+the result.
+
+The argument `A` should *not* be a matrix.  Rather, instead of matrices it should be a
+factorization object (e.g. produced by [`factorize`](@ref) or [`cholfact`](@ref)).
+The reason for this is that factorization itself is both expensive and typically allocates memory
+(although it can also be done in-place via, e.g., [`lufact!`](@ref)),
+and performance-critical situations requiring `ldiv!` usually also require fine-grained
+control over the factorization of `A`.
+"""
+ldiv!(Y, A, B)
+
+"""
+    rdiv!([Y,] A, B) -> Y
+
+Compute `A / B` in-place and store the result in `Y`, returning the result.
+If only two arguments are passed, then `rdiv!(A, B)` overwrites `A` with
+the result.
+
+The argument `B` should *not* be a matrix.  Rather, instead of matrices it should be a
+factorization object (e.g. produced by [`factorize`](@ref) or [`cholfact`](@ref)).
+The reason for this is that factorization itself is both expensive and typically allocates memory
+(although it can also be done in-place via, e.g., [`lufact!`](@ref)),
+and performance-critical situations requiring `rdiv!` usually also require fine-grained
+control over the factorization of `B`.
+"""
+rdiv!(Y, A, B)
 
 copy_oftype(A::AbstractArray{T}, ::Type{T}) where {T} = copy(A)
 copy_oftype(A::AbstractArray{T,N}, ::Type{S}) where {T,N,S} = convert(AbstractArray{S,N}, A)

base/linalg/linalg.jl

@@ -10,10 +10,7 @@ using Base.Sort: Forward
 using Base.LinAlg: AbstractTriangular, PosDefException, fillstored!
 
 import Base: +, -, *, \, /, &, |, xor, ==
-import Base: A_mul_B!, Ac_mul_B, Ac_mul_B!, At_mul_B, At_mul_B!
-import Base: A_mul_Bc, A_mul_Bt, Ac_mul_Bc, At_mul_Bt
-import Base: At_ldiv_B, Ac_ldiv_B, A_ldiv_B!
-import Base.LinAlg: At_ldiv_B!, Ac_ldiv_B!, A_rdiv_B!, A_rdiv_Bc!, mul!, ldiv!, rdiv!
+import Base.LinAlg: mul!, ldiv!, rdiv!
 
 import Base: @get!, acos, acosd, acot, acotd, acsch, asech, asin, asind, asinh,
     atan, atand, atanh, broadcast!, chol, conj!, cos, cosc, cosd, cosh, cospi, cot,

base/sparse/sparse.jl

@@ -138,13 +138,7 @@ julia> sB\x
  -1.1086956521739126
  -1.4565217391304346
 ```
-The `\` operation here performs the linear solution. Julia's parser provides convenient dispatch
-to specialized methods for the *transpose* of a matrix left-divided by a vector, or for the various combinations
-of transpose operations in matrix-matrix solutions. Many of these are further specialized for certain special
-matrix types. For example, `A\B` will end up calling [`Base.LinAlg.A_ldiv_B!`](@ref) while `A'\B` will end up calling
-[`Base.LinAlg.Ac_ldiv_B`](@ref), even though we used the same left-division operator. This works for matrices too: `A.'\B.'`
-would call [`Base.LinAlg.At_ldiv_Bt`](@ref). The left-division operator is pretty powerful and it's easy to write compact,
-readable code that is flexible enough to solve all sorts of systems of linear equations.
+The `\` operation here performs the linear solution. The left-division operator is pretty powerful and it's easy to write compact, readable code that is flexible enough to solve all sorts of systems of linear equations.
 
 ## Special matrices
 

doc/src/manual/linear-algebra.md

@@ -143,38 +143,15 @@ Base.LinAlg.stride1
 
 ## Low-level matrix operations
 
-Matrix operations involving transpositions operations like `A' \ B` are converted by the Julia
-parser into calls to specially named functions like [`Ac_ldiv_B`](@ref). If you want to overload these
-operations for your own types, then it is useful to know the names of these functions.
-
-Also, in many cases there are in-place versions of matrix operations that allow you to supply
+In many cases there are in-place versions of matrix operations that allow you to supply
 a pre-allocated output vector or matrix.  This is useful when optimizing critical code in order
 to avoid the overhead of repeated allocations. These in-place operations are suffixed with `!`
-below (e.g. [`A_mul_B!`](@ref)) according to the usual Julia convention.
+below (e.g. `mul!`) according to the usual Julia convention.
 
 ```@docs
-Base.LinAlg.A_ldiv_B!
-Base.A_ldiv_Bc
-Base.A_ldiv_Bt
-Base.LinAlg.A_mul_B!
-Base.A_mul_Bc
-Base.A_mul_Bt
-Base.A_rdiv_Bc
-Base.A_rdiv_Bt
-Base.Ac_ldiv_B
-Base.LinAlg.Ac_ldiv_B!
-Base.Ac_ldiv_Bc
-Base.Ac_mul_B
-Base.Ac_mul_Bc
-Base.Ac_rdiv_B
-Base.Ac_rdiv_Bc
-Base.At_ldiv_B
-Base.LinAlg.At_ldiv_B!
-Base.At_ldiv_Bt
-Base.At_mul_B
-Base.At_mul_Bt
-Base.At_rdiv_B
-Base.At_rdiv_Bt
+Base.LinAlg.mul!
+Base.LinAlg.ldiv!
+Base.LinAlg.rdiv!
 ```
 
 ## BLAS Functions