Implement sparse matrix copy! for unequal length.

Instead of relying on copy!(::AbstractMatrix, ::AbstractMatrix), the
dest matrix is prepared so that
sparse_compute_reshaped_colptr_and_rowval() can then be applied.

Author: martinholters

base/sparse/sparsematrix.jl

@@ -193,8 +193,7 @@ end
 copy(S::SparseMatrixCSC) =
     SparseMatrixCSC(S.m, S.n, copy(S.colptr), copy(S.rowval), copy(S.nzval))
 
-function copy!{TvA, TiA, TvB, TiB}(A::SparseMatrixCSC{TvA,TiA},
-                                   B::SparseMatrixCSC{TvB,TiB})
+function copy!(A::SparseMatrixCSC, B::SparseMatrixCSC)
     # If the two matrices have the same length then all the
     # elements in A will be overwritten.
     if length(A) == length(B)
@@ -208,10 +207,37 @@ function copy!{TvA, TiA, TvB, TiB}(A::SparseMatrixCSC{TvA,TiA},
             # This is like a "reshape B into A".
             sparse_compute_reshaped_colptr_and_rowval(A.colptr, A.rowval, A.m, A.n, B.colptr, B.rowval, B.m, B.n)
         end
-        copy!(A.nzval, B.nzval)
     else
-        invoke(Base.copy!, Tuple{AbstractMatrix{TvA}, AbstractMatrix{TvB}}, A, B)
+        length(A) >= length(B) || throw(BoundsError())
+        lB = length(B)
+        nnzA = nnz(A)
+        nnzB = nnz(B)
+        # Up to which col, row, and ptr in rowval/nzval will A be overwritten?
+        lastmodcolA = div(lB - 1, A.m) + 1
+        lastmodrowA = mod(lB - 1, A.m) + 1
+        lastmodptrA = A.colptr[lastmodcolA]
+        while lastmodptrA < A.colptr[lastmodcolA+1] && A.rowval[lastmodptrA] <= lastmodrowA
+            lastmodptrA += 1
+        end
+        lastmodptrA -= 1
+        if lastmodptrA >= nnzB
+            # A will have fewer non-zero elements; unmodified elements are kept at the end.
+            deleteat!(A.rowval, nnzB+1:lastmodptrA)
+            deleteat!(A.nzval, nnzB+1:lastmodptrA)
+        else
+            # A will have more non-zero elements; unmodified elements are kept at the end.
+            resize!(A.rowval, nnzB + nnzA - lastmodptrA)
+            resize!(A.nzval, nnzB + nnzA - lastmodptrA)
+            copy!(A.rowval, nnzB+1, A.rowval, lastmodptrA+1, nnzA-lastmodptrA)
+            copy!(A.nzval, nnzB+1, A.nzval, lastmodptrA+1, nnzA-lastmodptrA)
+        end
+        # Adjust colptr accordingly.
+        @inbounds for i in 2:length(A.colptr)
+            A.colptr[i] += nnzB - lastmodptrA
+        end
+        sparse_compute_reshaped_colptr_and_rowval(A.colptr, A.rowval, A.m, lastmodcolA-1, B.colptr, B.rowval, B.m, B.n)
     end
+    copy!(A.nzval, B.nzval)
     return A
 end
 

test/sparsedir/sparse.jl

@@ -257,14 +257,26 @@ let
     B = sprand(25, 1, 0.2)
     copy!(A, B)
     @test A[:] == B[:]
-    # Test size(A) != size(B)
-    B = sprand(3, 3, 0.2)
-    copy!(A, B)
-    @test A[1:9] == B[:]
+    # Test various size(A) / size(B) combinations
+    for mA in [5, 10, 20], nA in [5, 10, 20], mB in [5, 10, 20], nB in [5, 10, 20]
+        A = sprand(mA,nA,0.4)
+        Aorig = copy(A)
+        B = sprand(mB,nB,0.4)
+        if mA*nA >= mB*nB
+            copy!(A,B)
+            @assert(A[1:length(B)] == B[:])
+            @assert(A[length(B)+1:end] == Aorig[length(B)+1:end])
+        else
+            @test_throws BoundsError copy!(A,B)
+        end
+    end
     # Test eltype(A) != eltype(B), size(A) != size(B)
+    A = sprand(5, 5, 0.2)
+    Aorig = copy(A)
     B = sparse(rand(Float32, 3, 3))
     copy!(A, B)
     @test A[1:9] == B[:]
+    @test A[10:end] == Aorig[10:end]
     # Test eltype(A) != eltype(B), size(A) == size(B)
     A = sparse(rand(Float64, 3, 3))
     B = sparse(rand(Float32, 3, 3))