rename fastdensesparse -> fastdensesparsemul

Author: RomeoV

src/ThreadedDenseSparseMul.jl

@@ -4,20 +4,20 @@ import SparseArrays
 import SparseArrays: SparseMatrixCSC, SparseVector, nonzeroinds, nonzeros, findnz
 import Polyester: @batch
 
-export fastdensesparse!, fastdensesparse_threaded!
-export fastdensesparse_outer!, fastdensesparse_outer_threaded!
+export fastdensesparsemul!, fastdensesparsemul_threaded!
+export fastdensesparsemul_outer!, fastdensesparsemul_outer_threaded!
 
 const VecOrView{T} = Union{Vector{T}, SubArray{T, 1, Matrix{T}}}
 const MatOrView{T} = Union{Matrix{T}, SubArray{T, 2, Matrix{T}}}
 
 """
-    fastdensesparse!(C, A, B, α, β)
+    fastdensesparsemul!(C, A, B, α, β)
 
 BLAS like interface, computing `C .= β*C + α*A*B`, but way faster than Base would.
 
-Also see `fastdensesparse_threaded!` for a multi-threaded version using `Polyester.jl`.
+Also see `fastdensesparsemul_threaded!` for a multi-threaded version using `Polyester.jl`.
 """
-function fastdensesparse!(C::MatOrView{T}, A::MatOrView{T}, B::SparseMatrixCSC{T}, α::Number, β::Number) where T
+function fastdensesparsemul!(C::MatOrView{T}, A::MatOrView{T}, B::SparseMatrixCSC{T}, α::Number, β::Number) where T
     for j in axes(B, 2)
         C[:, j] .*= β
         C[:, j] .+= A * (α.*B[:, j])
@@ -26,12 +26,12 @@ function fastdensesparse!(C::MatOrView{T}, A::MatOrView{T}, B::SparseMatrixCSC{T
 end
 
 """
-    fastdensesparse!(C, A, B, α, β)
+    fastdensesparsemul!(C, A, B, α, β)
 
 Threaded, BLAS like interface, computing `C .= β*C + α*A*B`, but way faster than Base would.
-Also see `fastdensesparse!` for a single-threaded version.
+Also see `fastdensesparsemul!` for a single-threaded version.
 """
-function fastdensesparse_threaded!(C::MatOrView{T}, A::MatOrView{T}, B::SparseMatrixCSC{T}, α::Number, β::Number) where T
+function fastdensesparsemul_threaded!(C::MatOrView{T}, A::MatOrView{T}, B::SparseMatrixCSC{T}, α::Number, β::Number) where T
     @batch for j in axes(B, 2)
         C[:, j] .*= β
         C[:, j] .+= A * (α.*B[:, j])
@@ -40,27 +40,27 @@ function fastdensesparse_threaded!(C::MatOrView{T}, A::MatOrView{T}, B::SparseMa
 end
 
 """
-    fastdensesparse_outer!(C, a, b, α, β)
+    fastdensesparsemul_outer!(C, a, b, α, β)
 
 Fast outer product when computing `C .= β*C + α * a*b'`, but way faster than Base would.
 - `a` is a dense vector (or view), `b` is a sparse vector, `C` is a dense matrix (or view).
-Also see `fastdensesparse_outer_threaded!` for a multi-threaded version using `Polyester.jl`.
+Also see `fastdensesparsemul_outer_threaded!` for a multi-threaded version using `Polyester.jl`.
 """
-function fastdensesparse_outer!(C::MatOrView{T}, a::VecOrView{T}, b::SparseVector{T}, α::Number, β::Number) where T
+function fastdensesparsemul_outer!(C::MatOrView{T}, a::VecOrView{T}, b::SparseVector{T}, α::Number, β::Number) where T
     C[:, nonzeroinds(b)] .*=  β
     C[:, nonzeroinds(b)] .+=  a * (α.*nonzeros(b))'
     return C
 end
 
 """
-    fastdensesparse_outer_threaded!(C, a, b, α, β)
+    fastdensesparsemul_outer_threaded!(C, a, b, α, β)
 
 Threaded, fast outer product when computing `C .= β*C + α * a*b'`, but way faster than Base would, using `Polyester.jl`.
 - `a` is a dense vector (or view), `b` is a sparse vector, `C` is a dense matrix (or view).
 
-Also see `fastdensesparse_outer!` for a single-threaded version.
+Also see `fastdensesparsemul_outer!` for a single-threaded version.
 """
-function fastdensesparse_outer_threaded!(C::MatOrView{T}, a::VecOrView{T}, b::SparseVector{T}, α::Number, β::Number) where T
+function fastdensesparsemul_outer_threaded!(C::MatOrView{T}, a::VecOrView{T}, b::SparseVector{T}, α::Number, β::Number) where T
     inds = nonzeroinds(b)
     nzs = nonzeros(b)
     @batch for i in axes(nzs, 1)

test/runtests.jl

@@ -5,7 +5,7 @@ import Profile
 
 
 @testset "Compare with equivalent dense mul" begin
-  @testset "fastdensesparse" begin
+  @testset "fastdensesparsemul" begin
     @testset for trial in 1:10
       lhs = rand(500, 1000);
       rhs = sprand(1000, 10_000, 0.1);
@@ -14,26 +14,26 @@ import Profile
 
       buf = similar(baseline)
 
-      fastdensesparse!(buf, lhs, rhs, 1, 0)
+      fastdensesparsemul!(buf, lhs, rhs, 1, 0)
       @test buf ≈ baseline
-      fastdensesparse!(buf, lhs, rhs, -1, 0)
-      fastdensesparse_threaded!(buf, lhs, rhs, 1, 0)
+      fastdensesparsemul!(buf, lhs, rhs, -1, 0)
+      fastdensesparsemul_threaded!(buf, lhs, rhs, 1, 0)
       @test buf ≈ baseline
 
 
       # test @view interface and \beta \neq 0
       inds = collect(3:5:100)
       baseline[inds, :] .+= 2.5 * @view(lhs[inds, :]) * Matrix(rhs);
 
-      fastdensesparse!(@view(buf[inds, :]), @view(lhs[inds, :]), rhs, 2.5, 1)
+      fastdensesparsemul!(@view(buf[inds, :]), @view(lhs[inds, :]), rhs, 2.5, 1)
       @test buf ≈ baseline rtol=sqrt(eps(eltype(baseline)))
-      fastdensesparse!(@view(buf[inds, :]), @view(lhs[inds, :]), rhs, -2.5, 1)
-      fastdensesparse_threaded!(@view(buf[inds, :]), @view(lhs[inds, :]), rhs, 2.5, 1)
+      fastdensesparsemul!(@view(buf[inds, :]), @view(lhs[inds, :]), rhs, -2.5, 1)
+      fastdensesparsemul_threaded!(@view(buf[inds, :]), @view(lhs[inds, :]), rhs, 2.5, 1)
       @test buf ≈ baseline rtol=sqrt(eps(eltype(baseline)))
     end
   end
 
-  @testset "fastdensesparse_outer" begin
+  @testset "fastdensesparsemul_outer" begin
     @testset for trial in 1:10
       lhs = rand(500, 1000);
       rhs = sprand(1000, 10_000, 0.1);
@@ -43,18 +43,18 @@ import Profile
 
       buf = similar(baseline)
 
-      fastdensesparse_outer!(buf, @view(lhs[:, k]), rhs[k, :], 1, 0)
+      fastdensesparsemul_outer!(buf, @view(lhs[:, k]), rhs[k, :], 1, 0)
       @test buf ≈ baseline
-      fastdensesparse_outer!(buf, @view(lhs[:, k]), rhs[k, :], -1, 0)
-      fastdensesparse_outer_threaded!(buf, @view(lhs[:, k]), rhs[k, :], 1, 0)
+      fastdensesparsemul_outer!(buf, @view(lhs[:, k]), rhs[k, :], -1, 0)
+      fastdensesparsemul_outer_threaded!(buf, @view(lhs[:, k]), rhs[k, :], 1, 0)
       @test buf ≈ baseline
 
       baseline .+= 2.5 * lhs[:, (k+1):(k+1)] * Matrix(rhs)[(k+1):(k+1), :];
 
-      fastdensesparse_outer!(buf, lhs[:, k+1], rhs[k+1, :], 2.5, 1)
+      fastdensesparsemul_outer!(buf, lhs[:, k+1], rhs[k+1, :], 2.5, 1)
       @test buf ≈ baseline
-      fastdensesparse_outer!(buf, lhs[:, k+1], rhs[k+1, :], -2.5, 1)
-      fastdensesparse_outer_threaded!(buf, lhs[:, k+1], rhs[k+1, :], 2.5, 1)
+      fastdensesparsemul_outer!(buf, lhs[:, k+1], rhs[k+1, :], -2.5, 1)
+      fastdensesparsemul_outer_threaded!(buf, lhs[:, k+1], rhs[k+1, :], 2.5, 1)
       @test buf ≈ baseline
     end
   end