Skip to content

Commit d6b2dd3

Browse files
lkdvoslkdvos
committed
rename lapack_kwargs to alg_kwargs 
1 parent e663374 commit d6b2dd3

4 files changed

Lines changed: 59 additions & 59 deletions

File tree

‎src/implementations/eig.jl‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -83,14 +83,14 @@ function eig_full!(A::AbstractMatrix, DV, alg::LAPACK_EigAlgorithm)
8383
D, V = DV
8484

8585
do_gauge_fix = get(alg.kwargs, :gaugefix, default_gaugefix())::Bool
86-
lapack_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
86+
alg_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
8787

8888
if alg isa LAPACK_Simple
89-
isempty(lapack_kwargs) ||
89+
isempty(alg_kwargs) ||
9090
throw(ArgumentError("invalid keyword arguments for LAPACK_Simple"))
9191
YALAPACK.geev!(A, D.diag, V)
9292
else # alg isa LAPACK_Expert
93-
YALAPACK.geevx!(A, D.diag, V; lapack_kwargs...)
93+
YALAPACK.geevx!(A, D.diag, V; alg_kwargs...)
9494
end
9595

9696
do_gauge_fix && (V = gaugefix!(eig_full!, V))
@@ -102,14 +102,14 @@ function eig_vals!(A::AbstractMatrix, D, alg::LAPACK_EigAlgorithm)
102102
check_input(eig_vals!, A, D, alg)
103103
V = similar(A, complex(eltype(A)), (size(A, 1), 0))
104104

105-
lapack_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
105+
alg_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
106106

107107
if alg isa LAPACK_Simple
108-
isempty(lapack_kwargs) ||
108+
isempty(alg_kwargs) ||
109109
throw(ArgumentError("invalid keyword arguments for LAPACK_Simple"))
110110
YALAPACK.geev!(A, D, V)
111111
else # alg isa LAPACK_Expert
112-
YALAPACK.geevx!(A, D, V; lapack_kwargs...)
112+
YALAPACK.geevx!(A, D, V; alg_kwargs...)
113113
end
114114

115115
return D
@@ -146,10 +146,10 @@ function eig_full!(A::AbstractMatrix, DV, alg::GPU_EigAlgorithm)
146146
D, V = DV
147147

148148
do_gauge_fix = get(alg.kwargs, :gaugefix, default_gaugefix())::Bool
149-
lapack_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
149+
alg_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
150150

151151
if alg isa GPU_Simple
152-
isempty(lapack_kwargs) || @warn "invalid keyword arguments for GPU_Simple"
152+
isempty(alg_kwargs) || @warn "invalid keyword arguments for GPU_Simple"
153153
_gpu_geev!(A, D.diag, V)
154154
end
155155

@@ -162,10 +162,10 @@ function eig_vals!(A::AbstractMatrix, D, alg::GPU_EigAlgorithm)
162162
check_input(eig_vals!, A, D, alg)
163163
V = similar(A, complex(eltype(A)), (size(A, 1), 0))
164164

165-
lapack_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
165+
alg_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
166166

167167
if alg isa GPU_Simple
168-
isempty(lapack_kwargs) || @warn "invalid keyword arguments for GPU_Simple"
168+
isempty(alg_kwargs) || @warn "invalid keyword arguments for GPU_Simple"
169169
_gpu_geev!(A, D, V)
170170
end
171171

‎src/implementations/eigh.jl‎

Lines changed: 20 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -93,16 +93,16 @@ function eigh_full!(A::AbstractMatrix, DV, alg::LAPACK_EighAlgorithm)
9393
Dd = D.diag
9494

9595
do_gauge_fix = get(alg.kwargs, :gaugefix, default_gaugefix())::Bool
96-
lapack_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
96+
alg_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
9797

9898
if alg isa LAPACK_MultipleRelativelyRobustRepresentations
99-
YALAPACK.heevr!(A, Dd, V; lapack_kwargs...)
99+
YALAPACK.heevr!(A, Dd, V; alg_kwargs...)
100100
elseif alg isa LAPACK_DivideAndConquer
101-
YALAPACK.heevd!(A, Dd, V; lapack_kwargs...)
101+
YALAPACK.heevd!(A, Dd, V; alg_kwargs...)
102102
elseif alg isa LAPACK_Simple
103-
YALAPACK.heev!(A, Dd, V; lapack_kwargs...)
103+
YALAPACK.heev!(A, Dd, V; alg_kwargs...)
104104
else # alg isa LAPACK_Expert
105-
YALAPACK.heevx!(A, Dd, V; lapack_kwargs...)
105+
YALAPACK.heevx!(A, Dd, V; alg_kwargs...)
106106
end
107107

108108
do_gauge_fix && (V = gaugefix!(eigh_full!, V))
@@ -114,16 +114,16 @@ function eigh_vals!(A::AbstractMatrix, D, alg::LAPACK_EighAlgorithm)
114114
check_input(eigh_vals!, A, D, alg)
115115
V = similar(A, (size(A, 1), 0))
116116

117-
lapack_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
117+
alg_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
118118

119119
if alg isa LAPACK_MultipleRelativelyRobustRepresentations
120-
YALAPACK.heevr!(A, D, V; lapack_kwargs...)
120+
YALAPACK.heevr!(A, D, V; alg_kwargs...)
121121
elseif alg isa LAPACK_DivideAndConquer
122-
YALAPACK.heevd!(A, D, V; lapack_kwargs...)
122+
YALAPACK.heevd!(A, D, V; alg_kwargs...)
123123
elseif alg isa LAPACK_QRIteration # == LAPACK_Simple
124-
YALAPACK.heev!(A, D, V; lapack_kwargs...)
124+
YALAPACK.heev!(A, D, V; alg_kwargs...)
125125
else # alg isa LAPACK_Bisection == LAPACK_Expert
126-
YALAPACK.heevx!(A, D, V; lapack_kwargs...)
126+
YALAPACK.heevx!(A, D, V; alg_kwargs...)
127127
end
128128

129129
return D
@@ -169,16 +169,16 @@ function eigh_full!(A::AbstractMatrix, DV, alg::GPU_EighAlgorithm)
169169
Dd = D.diag
170170

171171
do_gauge_fix = get(alg.kwargs, :gaugefix, default_gaugefix())::Bool
172-
lapack_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
172+
alg_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
173173

174174
if alg isa GPU_Jacobi
175-
_gpu_heevj!(A, Dd, V; lapack_kwargs...)
175+
_gpu_heevj!(A, Dd, V; alg_kwargs...)
176176
elseif alg isa GPU_DivideAndConquer
177-
_gpu_heevd!(A, Dd, V; lapack_kwargs...)
177+
_gpu_heevd!(A, Dd, V; alg_kwargs...)
178178
elseif alg isa GPU_QRIteration # alg isa GPU_QRIteration == GPU_Simple
179-
_gpu_heev!(A, Dd, V; lapack_kwargs...)
179+
_gpu_heev!(A, Dd, V; alg_kwargs...)
180180
elseif alg isa GPU_Bisection # alg isa GPU_Bisection == GPU_Expert
181-
_gpu_heevx!(A, Dd, V; lapack_kwargs...)
181+
_gpu_heevx!(A, Dd, V; alg_kwargs...)
182182
else
183183
throw(ArgumentError("Unsupported eigh algorithm"))
184184
end
@@ -192,16 +192,16 @@ function eigh_vals!(A::AbstractMatrix, D, alg::GPU_EighAlgorithm)
192192
check_input(eigh_vals!, A, D, alg)
193193
V = similar(A, (size(A, 1), 0))
194194

195-
lapack_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
195+
alg_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
196196

197197
if alg isa GPU_Jacobi
198-
_gpu_heevj!(A, D, V; lapack_kwargs...)
198+
_gpu_heevj!(A, D, V; alg_kwargs...)
199199
elseif alg isa GPU_DivideAndConquer
200-
_gpu_heevd!(A, D, V; lapack_kwargs...)
200+
_gpu_heevd!(A, D, V; alg_kwargs...)
201201
elseif alg isa GPU_QRIteration
202-
_gpu_heev!(A, D, V; lapack_kwargs...)
202+
_gpu_heev!(A, D, V; alg_kwargs...)
203203
elseif alg isa GPU_Bisection
204-
_gpu_heevx!(A, D, V; lapack_kwargs...)
204+
_gpu_heevx!(A, D, V; alg_kwargs...)
205205
else
206206
throw(ArgumentError("Unsupported eigh algorithm"))
207207
end

‎src/implementations/gen_eig.jl‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -59,10 +59,10 @@ function gen_eig_full!(A::AbstractMatrix, B::AbstractMatrix, WV, alg::LAPACK_Eig
5959
W, V = WV
6060

6161
do_gauge_fix = get(alg.kwargs, :gaugefix, default_gaugefix())::Bool
62-
lapack_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
62+
alg_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
6363

6464
if alg isa LAPACK_Simple
65-
isempty(lapack_kwargs) ||
65+
isempty(alg_kwargs) ||
6666
throw(ArgumentError("invalid keyword arguments for LAPACK_Simple"))
6767
YALAPACK.ggev!(A, B, W.diag, V, similar(W.diag, eltype(A)))
6868
else # alg isa LAPACK_Expert
@@ -78,10 +78,10 @@ function gen_eig_vals!(A::AbstractMatrix, B::AbstractMatrix, W, alg::LAPACK_EigA
7878
check_input(gen_eig_vals!, A, B, W, alg)
7979
V = similar(A, complex(eltype(A)), (size(A, 1), 0))
8080

81-
lapack_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
81+
alg_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
8282

8383
if alg isa LAPACK_Simple
84-
isempty(lapack_kwargs) ||
84+
isempty(alg_kwargs) ||
8585
throw(ArgumentError("invalid keyword arguments for LAPACK_Simple"))
8686
YALAPACK.ggev!(A, B, W, V, similar(W, eltype(A)))
8787
else # alg isa LAPACK_Expert

‎src/implementations/svd.jl‎

Lines changed: 25 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -121,14 +121,14 @@ function svd_full!(A::AbstractMatrix, USVᴴ, alg::LAPACK_SVDAlgorithm)
121121
end
122122

123123
do_gauge_fix = get(alg.kwargs, :gaugefix, default_gaugefix())::Bool
124-
lapack_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
124+
alg_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
125125

126126
if alg isa LAPACK_QRIteration
127-
isempty(lapack_kwargs) ||
127+
isempty(alg_kwargs) ||
128128
throw(ArgumentError("invalid keyword arguments for LAPACK_QRIteration"))
129129
YALAPACK.gesvd!(A, view(S, 1:minmn, 1), U, Vᴴ)
130130
elseif alg isa LAPACK_DivideAndConquer
131-
isempty(lapack_kwargs) ||
131+
isempty(alg_kwargs) ||
132132
throw(ArgumentError("invalid keyword arguments for LAPACK_DivideAndConquer"))
133133
YALAPACK.gesdd!(A, view(S, 1:minmn, 1), U, Vᴴ)
134134
elseif alg isa LAPACK_Bisection
@@ -154,20 +154,20 @@ function svd_compact!(A::AbstractMatrix, USVᴴ, alg::LAPACK_SVDAlgorithm)
154154
U, S, Vᴴ = USVᴴ
155155

156156
do_gauge_fix = get(alg.kwargs, :gaugefix, default_gaugefix())::Bool
157-
lapack_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
157+
alg_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
158158

159159
if alg isa LAPACK_QRIteration
160-
isempty(lapack_kwargs) ||
160+
isempty(alg_kwargs) ||
161161
throw(ArgumentError("invalid keyword arguments for LAPACK_QRIteration"))
162162
YALAPACK.gesvd!(A, S.diag, U, Vᴴ)
163163
elseif alg isa LAPACK_DivideAndConquer
164-
isempty(lapack_kwargs) ||
164+
isempty(alg_kwargs) ||
165165
throw(ArgumentError("invalid keyword arguments for LAPACK_DivideAndConquer"))
166166
YALAPACK.gesdd!(A, S.diag, U, Vᴴ)
167167
elseif alg isa LAPACK_Bisection
168-
YALAPACK.gesvdx!(A, S.diag, U, Vᴴ; lapack_kwargs...)
168+
YALAPACK.gesvdx!(A, S.diag, U, Vᴴ; alg_kwargs...)
169169
elseif alg isa LAPACK_Jacobi
170-
isempty(lapack_kwargs) ||
170+
isempty(alg_kwargs) ||
171171
throw(ArgumentError("invalid keyword arguments for LAPACK_Jacobi"))
172172
YALAPACK.gesvj!(A, S.diag, U, Vᴴ)
173173
else
@@ -183,20 +183,20 @@ function svd_vals!(A::AbstractMatrix, S, alg::LAPACK_SVDAlgorithm)
183183
check_input(svd_vals!, A, S, alg)
184184
U, Vᴴ = similar(A, (0, 0)), similar(A, (0, 0))
185185

186-
lapack_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
186+
alg_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
187187

188188
if alg isa LAPACK_QRIteration
189-
isempty(lapack_kwargs) ||
189+
isempty(alg_kwargs) ||
190190
throw(ArgumentError("invalid keyword arguments for LAPACK_QRIteration"))
191191
YALAPACK.gesvd!(A, S, U, Vᴴ)
192192
elseif alg isa LAPACK_DivideAndConquer
193-
isempty(lapack_kwargs) ||
193+
isempty(alg_kwargs) ||
194194
throw(ArgumentError("invalid keyword arguments for LAPACK_DivideAndConquer"))
195195
YALAPACK.gesdd!(A, S, U, Vᴴ)
196196
elseif alg isa LAPACK_Bisection
197-
YALAPACK.gesvdx!(A, S, U, Vᴴ; lapack_kwargs...)
197+
YALAPACK.gesvdx!(A, S, U, Vᴴ; alg_kwargs...)
198198
elseif alg isa LAPACK_Jacobi
199-
isempty(lapack_kwargs) ||
199+
isempty(alg_kwargs) ||
200200
throw(ArgumentError("invalid keyword arguments for LAPACK_Jacobi"))
201201
YALAPACK.gesvj!(A, S, U, Vᴴ)
202202
else
@@ -337,15 +337,15 @@ function svd_full!(A::AbstractMatrix, USVᴴ, alg::GPU_SVDAlgorithm)
337337
end
338338

339339
do_gauge_fix = get(alg.kwargs, :gaugefix, default_gaugefix())::Bool
340-
lapack_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
340+
alg_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
341341

342342
if alg isa GPU_QRIteration
343-
isempty(lapack_kwargs) || @warn "invalid keyword arguments for GPU_QRIteration"
343+
isempty(alg_kwargs) || @warn "invalid keyword arguments for GPU_QRIteration"
344344
_gpu_gesvd_maybe_transpose!(A, view(S, 1:minmn, 1), U, Vᴴ)
345345
elseif alg isa GPU_SVDPolar
346-
_gpu_Xgesvdp!(A, view(S, 1:minmn, 1), U, Vᴴ; lapack_kwargs...)
346+
_gpu_Xgesvdp!(A, view(S, 1:minmn, 1), U, Vᴴ; alg_kwargs...)
347347
elseif alg isa GPU_Jacobi
348-
_gpu_gesvdj!(A, view(S, 1:minmn, 1), U, Vᴴ; lapack_kwargs...)
348+
_gpu_gesvdj!(A, view(S, 1:minmn, 1), U, Vᴴ; alg_kwargs...)
349349
else
350350
throw(ArgumentError("Unsupported SVD algorithm"))
351351
end
@@ -379,15 +379,15 @@ function svd_compact!(A::AbstractMatrix, USVᴴ, alg::GPU_SVDAlgorithm)
379379
U, S, Vᴴ = USVᴴ
380380

381381
do_gauge_fix = get(alg.kwargs, :gaugefix, default_gaugefix())::Bool
382-
lapack_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
382+
alg_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
383383

384384
if alg isa GPU_QRIteration
385-
isempty(lapack_kwargs) || @warn "invalid keyword arguments for GPU_QRIteration"
385+
isempty(alg_kwargs) || @warn "invalid keyword arguments for GPU_QRIteration"
386386
_gpu_gesvd_maybe_transpose!(A, S.diag, U, Vᴴ)
387387
elseif alg isa GPU_SVDPolar
388-
_gpu_Xgesvdp!(A, S.diag, U, Vᴴ; lapack_kwargs...)
388+
_gpu_Xgesvdp!(A, S.diag, U, Vᴴ; alg_kwargs...)
389389
elseif alg isa GPU_Jacobi
390-
_gpu_gesvdj!(A, S.diag, U, Vᴴ; lapack_kwargs...)
390+
_gpu_gesvdj!(A, S.diag, U, Vᴴ; alg_kwargs...)
391391
else
392392
throw(ArgumentError("Unsupported SVD algorithm"))
393393
end
@@ -403,15 +403,15 @@ function svd_vals!(A::AbstractMatrix, S, alg::GPU_SVDAlgorithm)
403403
check_input(svd_vals!, A, S, alg)
404404
U, Vᴴ = similar(A, (0, 0)), similar(A, (0, 0))
405405

406-
lapack_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
406+
alg_kwargs = Base.structdiff(alg.kwargs, NamedTuple{(:gaugefix,)})
407407

408408
if alg isa GPU_QRIteration
409-
isempty(lapack_kwargs) || @warn "invalid keyword arguments for GPU_QRIteration"
409+
isempty(alg_kwargs) || @warn "invalid keyword arguments for GPU_QRIteration"
410410
_gpu_gesvd_maybe_transpose!(A, S, U, Vᴴ)
411411
elseif alg isa GPU_SVDPolar
412-
_gpu_Xgesvdp!(A, S, U, Vᴴ; lapack_kwargs...)
412+
_gpu_Xgesvdp!(A, S, U, Vᴴ; alg_kwargs...)
413413
elseif alg isa GPU_Jacobi
414-
_gpu_gesvdj!(A, S, U, Vᴴ; lapack_kwargs...)
414+
_gpu_gesvdj!(A, S, U, Vᴴ; alg_kwargs...)
415415
else
416416
throw(ArgumentError("Unsupported SVD algorithm"))
417417
end

0 commit comments

Comments
 (0)