Add conversions

Author: pranavtbhat

benchmarks/conversion.jl

@@ -0,0 +1,29 @@
+sm = sprand(scale, scale, 0.1)
+svm = svmrand(scale, scale, 0.1)
+arr = full(sprand(scale, scale, 0.1))
+
+
+println("Conversion to Full array from SparseMatrixCSC")
+for i in 1:num_iters
+    @time full(sm);
+end
+
+println("Conversion to Full array from SparseMatrixCD")
+for i in 1:num_iters
+    @time full(svm);
+end
+
+println("Conversion from Full array to SparseMatrixCSC")
+for i in 1:num_iters
+    @time sparse(arr);
+end
+
+println("Conversion from Full array to SparseMatrixCD")
+for i in 1:num_iters
+    @time vsparse(arr);
+end
+
+println("Conversion from SparseMatrixCSC to SparseMatrixCD")
+for i in 1:num_iters
+    @time SparseMatrixCD(sm);
+end

benchmarks/run.jl

@@ -22,3 +22,7 @@ println("-----------------------------------------------------------------------
 println("Running benchmarks for Grid Concatenation")
     include("hvcat.jl")
 println("----------------------------------------------------------------------------")
+
+println("Running benchmarks for Matrix Conversions")
+    include("conversion.jl")
+println("----------------------------------------------------------------------------")

src/conversion.jl

@@ -4,5 +4,30 @@
 
 import Base: full
 
+export vsparse
+
 # Full
 full(A::SparseMatrixCD) = hcat(map(full, A.svlist)...)
+
+# Sparse
+function vsparse{Tv}(A::AbstractArray{Tv, 2})
+    m, n = size(A)
+    SparseMatrixCD{Tv, Int}(m, n, [sparse(A[:,c]) for c in 1 : size(A, 2)])
+end
+
+# Convert from SparseMatrixCSC to SparseMatrixCD
+function SparseMatrixCD{Tv, Ti}(X::SparseMatrixCSC{Tv, Ti})
+    m = X.m
+    n = X.n
+    svlist = Array{SparseVector{Tv, Ti}}(n)
+
+    colptrX = X.colptr
+    nzvalX = X.nzval
+    rowvalX = X.rowval
+
+    for col in 1 : n
+        rr = colptrX[col] : (colptrX[col+1] - 1)
+        svlist[col] = SparseVector{Tv, Ti}(m, rowvalX[rr], nzvalX[rr])
+    end
+    SparseMatrixCD{Tv, Ti}(m, n, svlist)
+end

src/definition.jl

@@ -4,7 +4,8 @@
 # are distjoint.
 ###
 
-import Base: size, nnz, show, copy
+import Base: size, nnz, show, copy, ==, isequal
+
 export SparseMatrixCD
 
 type SparseMatrixCD{Tv, Ti}
@@ -41,3 +42,7 @@ end
 
 # Copy
 copy{Tv, Ti}(x::SparseMatrixCD{Tv, Ti}) = SparseMatrixCD{Tv, Ti}(x.m, x.n, deepcopy(x.svlist))
+
+# Equality
+(==)(x::SparseMatrixCD, y::SparseMatrixCD) = (x.m == y.m) && (x.n == y.n) && reduce(&, map(==, x.svlist, y.svlist))
+isequal(x::SparseMatrixCD, y::SparseMatrixCD) = isequal(x.m, y.m) && isequal(x.n, y.n) && reduce(&, map(isequal, x.svlist, y.svlist))

test/definition.jl

@@ -0,0 +1,20 @@
+m = 5
+n = 10
+
+svlist_int = SparseVector{Int, Int}[spzeros(Int, m) for i in 1 : n]
+svlist_float = SparseVector{Float64, Int}[spzeros(Float64, m) for i in 1 : n]
+
+# Constructors
+svm_int = SparseMatrixCD{Int, Int}(m, n, svlist_int)
+svm_float = SparseMatrixCD{Float64, Int}(m, n, svlist_float)
+
+# Size
+@test size(svm_int) == (m, n)
+@test size(svm_int, 1) == m
+@test size(svm_int, 2) == n
+
+# NNZ
+@test nnz(svm_int) == mapreduce(nnz, +, 0, svlist_int)
+
+# Copy
+@test copy(svm_int) == svm_int

test/getindex.jl

@@ -0,0 +1,5 @@
+m = 5
+n = 10
+
+svlist = SparseVector{Int, Int}[spzeros(Int, m) for i in 1 : n]
+svm = SparseMatrixCD{Int, Int}(m, n, svlist)

test/runtests.jl

@@ -1,5 +1,4 @@
 using SparseVectorMatrix
 using Base.Test
 
-# write your own tests here
-@test 1 == 1
+include("definition.jl")