Merge pull request #10 from ranjanan/opt

Some memory optimisations

Author: ranjanan

src/classical.jl

@@ -127,7 +127,7 @@ function rs_direct_interpolation_pass1(T, A, splitting)
 
             if sum_strong_pos == 0
                 diag += sum_all_pos
-                beta = 0
+                beta = zero(beta)
             end
 
             neg_coeff = -1 * alpha / diag
@@ -152,7 +152,7 @@ function rs_direct_interpolation_pass1(T, A, splitting)
     end
 
     m = zeros(Ti, n)
-    sum = 0
+    sum = zero(eltype(m))
     for i = 1:n
         m[i] = sum
         sum += splitting[i]

src/splitting.jl

@@ -14,12 +14,11 @@ end
 			end
 		end
 	end
-	i, j, v = findnz(S)
 	RS_CF_splitting(sparse(i,j,v,n,n), sparse(j,i,v,n,n))
 end=#
 function split_nodes(::RS, S)
-	T = S'
-	RS_CF_splitting(S - spdiagm(diag(S)), T - spdiagm(diag(T)))
+	S = S - spdiagm(diag(S))
+	RS_CF_splitting(S, S')
 end
 
 function RS_CF_splitting(S::SparseMatrixCSC, T::SparseMatrixCSC)

src/strength.jl

@@ -4,62 +4,81 @@ struct Classical{T} <: Strength
 end
 Classical(;θ = 0.25) = Classical(θ)
 
-function strength_of_connection{T}(c::Classical{T}, A::SparseMatrixCSC)
+function strength_of_connection{T, Ti, Tv}(c::Classical{T}, A::SparseMatrixCSC{Tv, Ti})
 
     θ = c.θ
-    I = Int[]
-    J = Int[]
-    V = Float64[]
 
     m, n = size(A)
+    nz = nnz(A)
+    I = zeros(Ti, nz)
+    J = zeros(Ti, nz)
+    V = zeros(float(Tv), nz)
+    k = 1
 
     for i = 1:n
-        neighbors = A[:,i]
-        _m = find_max_off_diag(neighbors, i)
+        _m = find_max_off_diag(A, i)
         threshold = θ * _m
         for j in nzrange(A, i)
             row = A.rowval[j]
             val = A.nzval[j]
             if abs(val) >= threshold
                 if row != i
-                    push!(I, row)
-                    push!(J, i)
-                    push!(V, abs(val))
+                    I[k] = row
+                    J[k] = i
+                    V[k] = abs(val)
+                    k += 1
                 end
             end
 
             if row == i
-                push!(I, row)
-                push!(J, i)
-                push!(V, val)
+                I[k] = row
+                J[k] = i
+                V[k] = val
+                k += 1
             end
         end
     end
+    deleteat!(I, k:nz)
+    deleteat!(J, k:nz)
+    deleteat!(V, k:nz)
+
     S = sparse(I, J, V, m, n)
 
     scale_cols_by_largest_entry!(S)
 
-
     S', S
 end
 
-function find_max_off_diag(neighbors, col)
-    maxval = zero(eltype(neighbors))
-    for i in 1:length(neighbors.nzval)
-        maxval = max(maxval, ifelse(neighbors.nzind[i] == col, 0, abs(neighbors.nzval[i])))
+function find_max_off_diag(A, i)
+    m = zero(eltype(A))
+    for j in nzrange(A, i)
+        row = A.rowval[j]
+        val = A.nzval[j]
+        if row != i
+            m = max(m, abs(val))
+        end
     end
-    return maxval
+    m
+end
+
+function find_max(A, i)
+    m = zero(eltype(A))
+    for j in nzrange(A, i)
+        row = A.rowval[j]
+        val = A.nzval[j]
+        m = max(m, val)
+    end
+    m
 end
 
 function scale_cols_by_largest_entry!(A::SparseMatrixCSC)
 
     n = size(A, 1)
     for i = 1:n
-        _m = maximum(A[:,i])
+        _m = find_max(A, i)
         for j in nzrange(A, i)
             A.nzval[j] /= _m
         end
     end
-
     A
 end