Replaced the variable name vec in LP-HGLET.jl by v

Author: BoundaryValueProblems

src/LP-HGLET.jl

@@ -1,5 +1,5 @@
 """
-    function LPHGLET_Synthesis(dvec::Vector{Float64}, GP::GraphPart, BS::BasisSpec, G::GraphSig; method::Symbol = :L, ϵ::Float64 = 0.3)
+    function LPHGLET_Synthesis(dvec::Vector{Float64}, GP::GraphPart, BS::BasisSpec, G::GraphSig; gltype::Symbol = :L, ϵ::Float64 = 0.3)
 
 Perform Lapped-HGLET Synthesis transform
 
@@ -8,14 +8,14 @@ Perform Lapped-HGLET Synthesis transform
 * `GP`: a GraphPart object
 * `BS`: a BasisSpec object
 * `G`: a GraphSig object
-* `method`: :L or :Lsym, indicating which eigenvectors are used
+* `gltype`: :L or :Lsym, indicating which eigenvectors are used
 * `ϵ`: relative action bandwidth (default: 0.3)
 
 ### Output Argument
 * `f`: the reconstructed signal
 * `GS`: the reconstructed GraphSig object
 """
-function LPHGLET_Synthesis(dvec::Matrix{Float64}, GP::GraphPart, BS::BasisSpec, G::GraphSig; method::Symbol = :L, ϵ::Float64 = 0.3)
+function LPHGLET_Synthesis(dvec::Matrix{Float64}, GP::GraphPart, BS::BasisSpec, G::GraphSig; gltype::Symbol = :L, ϵ::Float64 = 0.3)
     # Preliminaries
     W = G.W
     inds = GP.inds
@@ -48,32 +48,32 @@ function LPHGLET_Synthesis(dvec::Matrix{Float64}, GP::GraphPart, BS::BasisSpec,
             if (j == jmax || count(!iszero, dmatrix[indr, j + 1, :]) == 0) && count(!iszero, dmatrix[indr, j, :]) > 0
                 # compute the eigenvectors
                 W_temp = W[indrs,indrs]
-                D_temp = sparse(Diagonal(dropdims(sum(W_temp, dims = 1), dims = 1)))
-                if method == :L
+                D_temp = Diagonal(vec(sum(W_temp, dims = 1)))
+                if gltype == :L
                     # compute the eigenvectors of L ==> svd(L)
-                    vec = svd(Matrix(D_temp - W_temp)).U
-                elseif method == :Lsym
+                    v = svd(Matrix(D_temp - W_temp)).U
+                elseif gltype == :Lsym
                     # check if one can assemble the Lsym
                     if minimum(sum(W[indrs, indrs], dims = 1)) > 10^3 * eps()
                         ### eigenvectors of L_sym ==> svd(L_sym)
-                        D_temp_p = sparse(Diagonal(dropdims(sum(W_temp, dims = 1), dims = 1).^(-1/2)))
-                        vec = svd(Matrix(D_temp_p * (D_temp - W_temp) * D_temp_p)).U
+                        D_temp_p = Diagonal(vec(sum(W_temp, dims = 1)).^(-0.5))
+                        v = svd(Matrix(D_temp_p * (D_temp - W_temp) * D_temp_p)).U
                     else
                         ### eigenvectors of L ==> svd(L)
-                        vec = svd(Matrix(D_temp - W_temp)).U
+                        v = svd(Matrix(D_temp - W_temp)).U
                     end
                 end
-                vec = vec[:, end:-1:1]
+                v = v[:,end:-1:1]
 
 
                 # standardize the eigenvector signs
-                standardize_eigenvector_signs!(vec)
+                standardize_eigenvector_signs!(v)
 
                 # construct unfolder operator custom to current region
                 P = Uf[indrs, :]'
 
                 # reconstruct the signal
-                f += (P * vec) * dmatrix[indr, j, :]
+                f += (P * v) * dmatrix[indr, j, :]
 
             end
         end
@@ -131,30 +131,30 @@ function LPHGLET_Analysis_All(G::GraphSig, GP::GraphPart; ϵ::Float64 = 0.3)
 
             # compute the eigenvectors
             W_temp = W[indrs,indrs]
-            D_temp = sparse(Diagonal(dropdims(sum(W_temp, dims = 1), dims = 1)))
+            D_temp = Diagonal(vec(sum(W_temp, dims = 1)))
             ## eigenvectors of L ==> svd(L)
-            vec = svd(Matrix(D_temp - W_temp)).U
+            v = svd(Matrix(D_temp - W_temp)).U
             ## eigenvectors of L_sym ==> svd(L_sym)
             if minimum(sum(W[indrs, indrs], dims = 1)) > 10^3 * eps()
                 ### eigenvectors of L_sym ==> svd(L_sym)
-                D_temp_p = sparse(Diagonal(dropdims(sum(W_temp, dims = 1), dims = 1).^(-1/2)))
-                vec_sym = svd(Matrix(D_temp_p * (D_temp - W_temp) * D_temp_p)).U
+                D_temp_p = Diagonal(vec(sum(W_temp, dims = 1)).^(-0.5))
+                v_sym = svd(Matrix(D_temp_p * (D_temp - W_temp) * D_temp_p)).U
             else
                 ### eigenvectors of L ==> svd(L)
-                vec_sym = deepcopy(vec)
+                v_sym = deepcopy(v)
             end
 
             # standardize the eigenvector signs
-            vec = vec[:, end:-1:1]
-            standardize_eigenvector_signs!(vec)
-            vec_sym = vec_sym[:, end:-1:1]
-            standardize_eigenvector_signs!(vec_sym)
+            v = v[:,end:-1:1]
+            standardize_eigenvector_signs!(v)
+            v_sym = v_sym[:,end:-1:1]
+            standardize_eigenvector_signs!(v_sym)
 
             # construct unfolding operator custom to current region
             P = Uf[indrs, :]'
             # obtain the expansion coefficients
-            dmatrixlH[indr, j, :] = (P * vec)' * G.f
-            dmatrixlHsym[indr, j, :] = (P * vec_sym)' * G.f
+            dmatrixlH[indr, j, :] = (P * v)' * G.f
+            dmatrixlHsym[indr, j, :] = (P * v_sym)' * G.f
         end
     end
 
@@ -164,16 +164,16 @@ end
 
 
 
-function standardize_eigenvector_signs!(vec)
+function standardize_eigenvector_signs!(v)
     # standardize the eigenvector signs for HGLET (different with NGWPs)
-    for col = 1:size(vec, 2)
+    for col = 1:size(v, 2)
         row = 1
         standardized = false
         while !standardized
-            if vec[row, col] > 10^3 * eps()
+            if v[row, col] > 10^3 * eps()
                 standardized = true
-            elseif vec[row,col] < -10^3 * eps()
-                vec[:, col] = -vec[:, col]
+            elseif v[row,col] < -10^3 * eps()
+                v[:, col] = -v[:, col]
             else
                 row += 1
             end
@@ -201,33 +201,33 @@ function HGLET_dictionary(GP::GraphPart, G::GraphSig; gltype::Symbol = :L)
     dictionary = zeros(N, jmax, N)
     for j = 1:jmax
         BS = BasisSpec(collect(enumerate(j * ones(Int, N))))
-        dictionary[:, j, :] = HGLET_Synthesis(Matrix{Float64}(I, N, N), GP, BS, G; gltype = method)[1]'
+        dictionary[:, j, :] = HGLET_Synthesis(Matrix{Float64}(I, N, N), GP, BS, G; gltype = gltype)[1]'
     end
     return dictionary
 end
 
 """
-    LPHGLET_dictionary(GP::GraphPart, G::GraphSig; method::Symbol = :L, ϵ::Float64 = 0.3)
+    LPHGLET_dictionary(GP::GraphPart, G::GraphSig; gltype::Symbol = :L, ϵ::Float64 = 0.3)
 
 assemble the whole LP-HGLET dictionary
 
 ### Input Arguments
 * `GP`: a GraphPart object
 * `G`:  a GraphSig object
-* `method`: `:L` or `:Lsym`
+* `gltype`: `:L` or `:Lsym`
 * `ϵ`: relative action bandwidth (default: 0.3)
 
 ### Output Argument
 * `dictionary`: the LP-HGLET dictionary
 
 """
-function LPHGLET_dictionary(GP::GraphPart, G::GraphSig; method::Symbol = :L, ϵ::Float64 = 0.3)
+function LPHGLET_dictionary(GP::GraphPart, G::GraphSig; gltype::Symbol = :L, ϵ::Float64 = 0.3)
     N = size(G.W, 1)
     jmax = size(GP.rs, 2)
     dictionary = zeros(N, jmax, N)
     for j = 1:jmax
         BS = BasisSpec(collect(enumerate(j * ones(Int, N))))
-        dictionary[:, j, :] = LPHGLET_Synthesis(Matrix{Float64}(I, N, N), GP, BS, G; method = method, ϵ = ϵ)[1]'
+        dictionary[:, j, :] = LPHGLET_Synthesis(Matrix{Float64}(I, N, N), GP, BS, G; gltype = gltype, ϵ = ϵ)[1]'
     end
     return dictionary
 end

test/dissertations/htli/scripts/Figure8.10.jl

@@ -2,8 +2,8 @@ cd(@__DIR__); include("setups/path512.jl")
 pyplot(dpi = 200)
 
 ## construct full HGLET and Lapped-HGLET dictionaries
-@time HGLET_dic = HGLET_dictionary(GP, G_Sig; method = :L)
-@time LPHGLET_dic = LPHGLET_dictionary(GP, G_Sig; method = :L, ϵ = 0.3)
+@time HGLET_dic = HGLET_dictionary(GP, G_Sig; gltype = :L)
+@time LPHGLET_dic = LPHGLET_dictionary(GP, G_Sig; gltype = :L, ϵ = 0.3)
 
 j = 3; k = 2; l = 6;
 WH = HGLET_dic[GP.rs[k, j]:(GP.rs[k + 1, j] - 1), j, :]'

test/dissertations/htli/scripts/Figure8.9.jl

@@ -2,8 +2,8 @@ cd(@__DIR__); include("setups/rgc100.jl")
 gr(dpi = 200)
 
 ## construct full HGLET and Lapped-HGLET dictionaries
-@time HGLET_dic = HGLET_dictionary(GP, G_Sig; method = :L)
-@time LPHGLET_dic = LPHGLET_dictionary(GP, G_Sig; method = :L, ϵ = 0.3)
+@time HGLET_dic = HGLET_dictionary(GP, G_Sig; gltype = :L)
+@time LPHGLET_dic = LPHGLET_dictionary(GP, G_Sig; gltype = :L, ϵ = 0.3)
 
 ## generate figures
 # pre-selected (j, k, l)s