Add a few fit candidates tests

Author: ranjanan

src/aggregation.jl

@@ -81,51 +81,20 @@ construct_R(::HermitianSymmetry, P) = P'
 
 function fit_candidates(AggOp, B, tol = 1e-10)
 
-    # K1 = Int(size(B, 1) / N_fine)
-    # K2 = size(B, 2)
-
     A = AggOp.'
-
     n_coarse = size(A, 2)
     n_fine = size(A, 1)
     n_col = n_coarse
 
-    # R = zeros(eltype(B), N_coarse, K2, K2)
     R = zeros(eltype(B), n_coarse)
-    # Qx = zeros(eltype(B), nnz(AggOp), K1, K2)
     Qx = zeros(eltype(B), nnz(A))
 
-
-    # R = vec(R)
-    # Qx = vec(Qx)
-
-    # n_row = N_fine
-    # n_col = N_coarse
-
-    # BS = K1 * K2
-
-    #=for i = 1:n_col
-        Ax_start = 1 + BS * A.colptr[i]
-
-        for j in nzrange(A, i)
-            B_start = 1 + BS * A.rowval[j]
-            B_end = B_start + BS
-            @show B_start
-            @show B_end
-            for ind in B_start:B_end
-                A.nzval[ind + Ax_start] = B[ind]
-            end
-            Ax_start += BS
-        end
-    end=#
-    # copy!(A.nzval, B)
     copy!(Qx, B)
-    # @show size(A.nzval)
-    # @show size(B)
+    copy!(A.nzval, B)
 
+    k = 1
     for i = 1:n_col
         norm_i = norm_col(A, Qx, i)
-        # norm_i = norm(A[:,i])
         threshold_i = tol * norm_i
         if norm_i > threshold_i
             scale = 1 / norm_i
@@ -136,82 +105,21 @@ function fit_candidates(AggOp, B, tol = 1e-10)
         end
         for j in nzrange(A, i)
             row = A.rowval[j]
-            Qx[row] *= scale
+            # Qx[row] *= scale
+            #@show k
+            Qx[k] *= scale
+            k += 1
         end
-        #=col_start = A.colptr[i]
-        col_end = A.colptr[i+1]
-
-        Ax_start = 1 + BS * col_start
-        Ax_end = 1 + BS * col_end
-        R_start = 1 + i * K2 * K2
-
-        for bj = 1:K2
-            norm_j = zero(eltype(A))
-            Ax_col = Ax_start + bj
-            while Ax_col < Ax_end
-                norm_j += norm(A.nzval[Ax_col])
-                Ax_col += K2
-            end
-            norm_j = sqrt(norm_j)
-
-            threshold_j = tol * norm_j
-
-            for bi = 1:bj
-                dot_prod = zero(eltype(A))
-
-                Ax_bi = Ax_start + bj
-                Ax_bj = Ax_start + bj
-                while Ax_bi < Ax_end
-                    dot_prod += dot(A.nzval[Ax_bj], A.nzval[Ax_bi])
-                    Ax_bi    += K2
-                    Ax_bj    += K2
-                end
-
-                Ax_bi = Ax_start + bi;
-                Ax_bj = Ax_start + bj;
-                while Ax_bi < Ax_end
-                    A.nzval[Ax_bj] -= dot_prod * A.nzval[Ax_bi]
-                    Ax_bi  += K2
-                    Ax_bj  += K2
-                end
-
-                R[R_start + K2 * bi + bj] = dot_prod
-            end
-
-            norm_j = zero(eltype(A))
-            Ax_bj = Ax_start + bj
-            while Ax_bj < Ax_end
-                norm_j += norm(A.nzval[Ax_bj])
-                Ax_bj  += K2
-                norm_j = sqrt(norm_j)
-            end
-
-            if norm_j > threshold_j
-                scale = 1 / norm_j
-                R[R_start + K2 * bj + bj] = norm_j
-            else
-                scale = zero(eltype(A))
-                R[R_start + K2 * bj + bj] = 0
-            end
-
-            Ax_bj = Ax_start + bj
-            while Ax_bj < Ax_end
-                A.nzval[Ax_bj] *= scale
-                Ax_bj  += K2
-            end
-        end=#
     end
 
-    #Q = SparseMatrixCSC(N_coarse, N_fine,
-                        #.colptr, A.rowval, Qx)
-
-    #R = reshape(R, N_coarse, K2)
     SparseMatrixCSC(size(A)..., A.colptr, A.rowval, Qx), R
+    # A, R
 end
 function norm_col(A, Qx, i)
     s = zero(eltype(A))
     for j in nzrange(A, i)
-        val = Qx[A.rowval[j]]
+        # val = Qx[A.rowval[j]]
+        val = A.nzval[A.rowval[j]]
         s += val*val
     end
     sqrt(s)

test/runtests.jl

@@ -249,6 +249,9 @@ end
         test_standard_aggregation()
 end
 
+@testset "Fit Candidates" begin
+        test_fit_candidates()
+end
 end
 
 end

test/sa_tests.jl

@@ -134,4 +134,53 @@ function test_standard_aggregation()
         end
     end
 
+end
+
+# Test fit_candidates 
+function test_fit_candidates()
+
+    cases = generate_fit_candidates_cases()
+
+    for (i, (AggOp, fine_candidates)) in enumerate(cases)
+   
+        mask_candidates!(AggOp, fine_candidates)
+
+        Q, coarse_candidates = fit_candidates(AggOp, fine_candidates)
+
+        @test isapprox(fine_candidates, Q * coarse_candidates)
+        @test isapprox(Q * (Q' * fine_candidates), fine_candidates)
+    end
+end
+function mask_candidates!(A,B)
+    B[(diff(A.colptr) .== 0)] = 0
+end
+
+function generate_fit_candidates_cases()
+    cases = []
+
+    for T in (Float32, Float64)
+
+        # One candidate
+        AggOp = SparseMatrixCSC(2, 5, collect(1:6), 
+                        [1,1,1,2,2], ones(T,5))
+        B =  ones(T,5)
+        push!(cases, (AggOp, B))
+
+        AggOp = SparseMatrixCSC(2, 5, collect(1:6), 
+                        [2,2,1,1,1], ones(T,5))
+        B = ones(T, 5)
+        push!(cases, (AggOp, B))
+
+        AggOp = SparseMatrixCSC(3, 9, collect(1:10), 
+                        [1,1,1,2,2,2,3,3,3], ones(T, 9))
+        B = ones(T, 9)
+        push!(cases, (AggOp, B))
+
+        #AggOp = SparseMatrixCSC(3, 9, collect(1:10), 
+                        #[3,2,1,1,2,3,2,1,3], ones(T,9))
+        #B = T.(collect(1:9))
+        #push!(cases, (AggOp, B))
+    end
+
+    cases
 end