Multiplying triangular sparse matrix with sparse matrix fails to return sparse matrix

[KlausC]

Multiplying an UpperTriangular{SparseMatrixCSC} with a SparseMatrixCSC should return a sparse matrix. It returns a dense matrix as of version 1.2.
Computational effort should be approximately 1/2 of sparse multiplication of SparseMatrixCSC.

julia> VERSION
v"1.4.1" # same for v"1.2.0"
julia> X = UpperTriangular(sprand(100, 100, 10*1e-2));
julia> Y = sprand(100, 10, 10*1e-2);
julia> typeof(X * Y)
Array{Float64,2}

With version 1, we have the same error as in #35609

julia> VERSION
v"1.0.5"
julia> X = UnitUpperTriangular(sprand(100, 100, 10*1e-2));
julia> Y = sprand(100, 10, 10*1e-2);
julia> X * Y;
ERROR: MethodError: no method matching lmul!(::UnitUpperTriangular{Float64,SparseMatrixCSC{Float64,Int64}}, ::SparseMatrixCSC{Float64,Int64})

[Micket]

julia/stdlib/SparseArrays/src/linalg.jl

Lines 767 to 768 in 2f90dde

	(\)(L::TriangularSparse, B::AbstractSparseMatrixCSC) = ldiv!(L, Array(B))
	(*)(L::TriangularSparse, B::AbstractSparseMatrixCSC) = lmul!(L, Array(B))

Looks to me that there was some type of attempt to treat * and \ similarly, though, I can't think of any case where you actually would want to do that.

Y*X actually does the right thing there;

julia/stdlib/SparseArrays/src/linalg.jl

Lines 49 to 50 in 2f90dde

	*(A::AbstractSparseMatrixCSC{TA}, B::AdjOrTransStridedOrTriangularMatrix{Tx}) where {TA,Tx} =
	(T = promote_op(matprod, TA, Tx); mul!(similar(B, T, (size(A, 1), size(B, 2))), A, B, true, false))

and, as far as I can see, this methods exists and does the right thing already:

julia/stdlib/SparseArrays/src/linalg.jl

Lines 128 to 129 in 2f90dde

	*(X::AdjOrTransStridedOrTriangularMatrix, A::AbstractSparseMatrixCSC{TvA}) where {TvA} =
	(T = promote_op(matprod, eltype(X), TvA); mul!(similar(X, T, (size(X, 1), size(A, 2))), X, A, true, false))

and already does the correct thing.

So, i think this should simply be removed:

(*)(L::TriangularSparse, B::AbstractSparseMatrixCSC) = lmul!(L, Array(B))

(edit: I totally missed that KlausC already had a PR going)

[KlausC]

Y*X actually does the right thing there;

The point of T * A is the return type, which should be sparse, not dense.

as far as I can see, this methods exists and does the right thing already

The problem with A * T is the execution efficiency. mul! is using a generic implementation here, which does not take much advantage of the sparsity.

The pending PR fixed both cases using the famous Gustafson multiplication algorithm.