Let rdiv! accept a LU factorization object

[zsoerenm]

The documentation of rdiv! implies that rdiv! does accept an factorization object. While this true for ldiv! it has not been implemented for rdiv!, yet.

  rdiv!(A, B)

  Compute A / B in-place and overwriting A to store 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 or cholesky). 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., lu!), and performance-critical situations requiring rdiv! usually also require fine-grained control
  over the factorization of B.

This is an attempt to fix this at least for the lu factorization.

[dkarrasch]

Very nice work! Based on the swap changes in this PR, we could add support for lmul! and rmul! with LU objects.

function LinearAlgebra.lmul!(F::LU, B::AbstractMatrix)
    lmul!(UnitLowerTriangular(F.factors), lmul!(UpperTriangular(F.factors), B))
    _apply_inverse_ipiv_rows!(F, B)
end

function LinearAlgebra.rmul!(A::AbstractMatrix, F::LU)
    _apply_ipiv_cols!(F, A)
    rmul!(rmul!(A, UnitLowerTriangular(F.factors)), UpperTriangular(F.factors))
end

This might be helpful in cases of very large matrices...? For instance, if F was constructed from lu!(A), then A is no longer available to compute A * B or B * A. Moreover, the multiplication is inplace of B.

[carstenbauer]

Since the changes have been approved, is there any chance for this to be in 1.2?