Skip to content

Commit 4648173

Browse files
lkdvoslkdvos
committed
runic formatter
1 parent 4d28314 commit 4648173

23 files changed

Lines changed: 479 additions & 549 deletions

‎docs/make.jl‎

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -8,18 +8,18 @@ pages = [
88
]
99

1010
makedocs(;
11-
modules=[BlockTensorKit],
12-
sitename="BlockTensorKit.jl",
13-
authors="Lukas Devos",
14-
warnonly=[:missing_docs, :cross_references],
15-
format=Documenter.HTML(;
16-
prettyurls=get(ENV, "CI", nothing) == "true",
17-
mathengine=MathJax(),
18-
repolink="https://github.com/lkdvos/BlockTensorKit.jl.git",
11+
modules = [BlockTensorKit],
12+
sitename = "BlockTensorKit.jl",
13+
authors = "Lukas Devos",
14+
warnonly = [:missing_docs, :cross_references],
15+
format = Documenter.HTML(;
16+
prettyurls = get(ENV, "CI", nothing) == "true",
17+
mathengine = MathJax(),
18+
repolink = "https://github.com/lkdvos/BlockTensorKit.jl.git",
1919
),
20-
pages=pages,
21-
pagesonly=true,
22-
repo="github.com/lkdvos/BlockTensorKit.jl.git",
20+
pages = pages,
21+
pagesonly = true,
22+
repo = "github.com/lkdvos/BlockTensorKit.jl.git",
2323
)
2424

25-
deploydocs(; repo="github.com/lkdvos/BlockTensorKit.jl.git", push_preview=true)
25+
deploydocs(; repo = "github.com/lkdvos/BlockTensorKit.jl.git", push_preview = true)

‎src/auxiliary/sparsetensorarray.jl‎

Lines changed: 40 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -1,33 +1,33 @@
11
# SparseBlockTensorMap parent array
22
# ---------------------------------
3-
struct SparseTensorArray{S,N₁,N₂,T<:AbstractTensorMap{<:Any,S,N₁,N₂},N} <:
4-
AbstractArray{T,N}
5-
data::Dict{CartesianIndex{N},T}
6-
space::TensorMapSumSpace{S,N₁,N₂}
7-
function SparseTensorArray{S,N₁,N₂,T,N}(
8-
data::Dict{CartesianIndex{N},T}, space::TensorMapSumSpace{S,N₁,N₂}
9-
) where {S,N₁,N₂,T,N}
3+
struct SparseTensorArray{S, N₁, N₂, T <: AbstractTensorMap{<:Any, S, N₁, N₂}, N} <:
4+
AbstractArray{T, N}
5+
data::Dict{CartesianIndex{N}, T}
6+
space::TensorMapSumSpace{S, N₁, N₂}
7+
function SparseTensorArray{S, N₁, N₂, T, N}(
8+
data::Dict{CartesianIndex{N}, T}, space::TensorMapSumSpace{S, N₁, N₂}
9+
) where {S, N₁, N₂, T, N}
1010
N₁ + N₂ == N || throw(
1111
TypeError(
1212
:SparseTensorArray,
13-
SparseTensorArray{S,N₁,N₂,T,N₁ + N₂},
14-
SparseTensorArray{S,N₁,N₂,T,N},
13+
SparseTensorArray{S, N₁, N₂, T, N₁ + N₂},
14+
SparseTensorArray{S, N₁, N₂, T, N},
1515
),
1616
)
17-
return new{S,N₁,N₂,T,N}(data, space)
17+
return new{S, N₁, N₂, T, N}(data, space)
1818
end
1919
end
2020

21-
function SparseTensorArray{S,N₁,N₂,T,N}(
22-
::UndefInitializer, space::TensorMapSumSpace{S,N₁,N₂}
23-
) where {S,N₁,N₂,T<:AbstractTensorMap{<:Any,S,N₁,N₂},N}
24-
return SparseTensorArray{S,N₁,N₂,T,N}(Dict{CartesianIndex{N},T}(), space)
21+
function SparseTensorArray{S, N₁, N₂, T, N}(
22+
::UndefInitializer, space::TensorMapSumSpace{S, N₁, N₂}
23+
) where {S, N₁, N₂, T <: AbstractTensorMap{<:Any, S, N₁, N₂}, N}
24+
return SparseTensorArray{S, N₁, N₂, T, N}(Dict{CartesianIndex{N}, T}(), space)
2525
end
2626

2727
function SparseTensorArray(
28-
data::Dict{CartesianIndex{N},T}, space::TensorMapSumSpace{S,N₁,N₂}
29-
) where {S,N₁,N₂,T,N}
30-
return SparseTensorArray{S,N₁,N₂,T,N}(data, space)
28+
data::Dict{CartesianIndex{N}, T}, space::TensorMapSumSpace{S, N₁, N₂}
29+
) where {S, N₁, N₂, T, N}
30+
return SparseTensorArray{S, N₁, N₂, T, N}(data, space)
3131
end
3232

3333
Base.pairs(A::SparseTensorArray) = pairs(A.data)
@@ -41,29 +41,29 @@ TensorKit.space(A::SparseTensorArray) = A.space
4141
Base.size(A::SparseTensorArray) = ntuple(i -> length(space(A)[i]), ndims(A))
4242

4343
@inline function Base.getindex(
44-
A::SparseTensorArray{S,N₁,N₂,T,N}, I::Vararg{Int,N}
45-
) where {S,N₁,N₂,T,N}
44+
A::SparseTensorArray{S, N₁, N₂, T, N}, I::Vararg{Int, N}
45+
) where {S, N₁, N₂, T, N}
4646
@boundscheck checkbounds(A, I...)
4747
return @inbounds get(A.data, CartesianIndex(I)) do
4848
return fill!(similar(T, eachspace(A)[I...]), zero(scalartype(T)))
4949
end
5050
end
5151
@inline function getindex!(
52-
A::SparseTensorArray{S,N₁,N₂,T,N}, I::CartesianIndex{N}
53-
) where {S,N₁,N₂,T,N}
52+
A::SparseTensorArray{S, N₁, N₂, T, N}, I::CartesianIndex{N}
53+
) where {S, N₁, N₂, T, N}
5454
@boundscheck checkbounds(A, I)
5555
return @inbounds get!(A.data, I) do
5656
return fill!(similar(T, eachspace(A)[I]), zero(scalartype(T)))
5757
end
5858
end
5959
@inline function getindex!(
60-
A::SparseTensorArray{S,N₁,N₂,T,N}, I::Vararg{Int,N}
61-
) where {S,N₁,N₂,T,N}
60+
A::SparseTensorArray{S, N₁, N₂, T, N}, I::Vararg{Int, N}
61+
) where {S, N₁, N₂, T, N}
6262
return getindex!(A, CartesianIndex(I))
6363
end
6464
@inline function Base.setindex!(
65-
A::SparseTensorArray{S,N₁,N₂,T,N}, v, I::Vararg{Int,N}
66-
) where {S,N₁,N₂,T,N}
65+
A::SparseTensorArray{S, N₁, N₂, T, N}, v, I::Vararg{Int, N}
66+
) where {S, N₁, N₂, T, N}
6767
@boundscheck begin
6868
checkbounds(A, I...)
6969
checkspaces(A, v, I...)
@@ -72,26 +72,26 @@ end
7272
return A
7373
end
7474

75-
function Base.delete!(A::SparseTensorArray, I::Vararg{Int,N}) where {N}
75+
function Base.delete!(A::SparseTensorArray, I::Vararg{Int, N}) where {N}
7676
return delete!(A.data, CartesianIndex(I))
7777
end
7878
Base.delete!(A::SparseTensorArray, I::CartesianIndex) = delete!(A.data, I)
7979
Base.empty!(A::SparseTensorArray) = empty!(A.data)
80-
function Base.haskey(A::SparseTensorArray, I::Vararg{Int,N}) where {N}
80+
function Base.haskey(A::SparseTensorArray, I::Vararg{Int, N}) where {N}
8181
return haskey(A.data, CartesianIndex(I))
8282
end
8383
Base.haskey(A::SparseTensorArray, I::CartesianIndex) = haskey(A.data, I)
8484

8585
function Base.similar(
86-
::SparseTensorArray, ::Type{T}, spaces::TensorMapSumSpace{S,N₁,N₂}
87-
) where {S,N₁,N₂,T<:AbstractTensorMap{<:Any,S,N₁,N₂}}
86+
::SparseTensorArray, ::Type{T}, spaces::TensorMapSumSpace{S, N₁, N₂}
87+
) where {S, N₁, N₂, T <: AbstractTensorMap{<:Any, S, N₁, N₂}}
8888
N = N₁ + N₂
89-
return SparseTensorArray{S,N₁,N₂,T,N}(Dict{CartesianIndex{N},T}(), spaces)
89+
return SparseTensorArray{S, N₁, N₂, T, N}(Dict{CartesianIndex{N}, T}(), spaces)
9090
end
9191

9292
Base.@propagate_inbounds function Base.copyto!(
93-
t::SparseTensorArray, v::SubArray{T,N,A}
94-
) where {T,N,A<:SparseTensorArray}
93+
t::SparseTensorArray, v::SubArray{T, N, A}
94+
) where {T, N, A <: SparseTensorArray}
9595
undropped_parentindices = map(Base.parentindices(v)) do I
9696
I isa Base.ScalarIndex ? (I:I) : I
9797
end
@@ -108,8 +108,8 @@ Base.@propagate_inbounds function Base.copyto!(
108108
end
109109

110110
Base.@propagate_inbounds function Base.copyto!(
111-
t::SubArray{T,N,A}, v::SparseTensorArray
112-
) where {T,N,A<:SparseTensorArray}
111+
t::SubArray{T, N, A}, v::SparseTensorArray
112+
) where {T, N, A <: SparseTensorArray}
113113
undropped_parentindices = map(Base.parentindices(t)) do I
114114
I isa Base.ScalarIndex ? (I:I) : I
115115
end
@@ -126,11 +126,9 @@ Base.@propagate_inbounds function Base.copyto!(
126126
end
127127

128128
Base.@propagate_inbounds function Base.copyto!(
129-
dest::SparseTensorArray,
130-
Rdest::CartesianIndices,
131-
src::SparseTensorArray,
132-
Rsrc::CartesianIndices,
133-
)
129+
dest::SparseTensorArray, Rdest::CartesianIndices,
130+
src::SparseTensorArray, Rsrc::CartesianIndices,
131+
)
134132
isempty(Rdest) && return dest
135133
if size(Rdest) != size(Rsrc)
136134
throw(
@@ -174,10 +172,9 @@ function _newindices(I::Tuple, indices::Tuple)
174172
end
175173

176174
function Base._unsafe_getindex(
177-
::IndexCartesian,
178-
t::SparseTensorArray{S,N₁,N₂,T,N},
179-
I::Vararg{Union{Real,AbstractArray},N},
180-
) where {S,N₁,N₂,T,N}
175+
::IndexCartesian,
176+
t::SparseTensorArray{S, N₁, N₂, T, N}, I::Vararg{Union{Real, AbstractArray}, N},
177+
) where {S, N₁, N₂, T, N}
181178
dest = similar(t, eltype(t), space(eachspace(t)[I...]))
182179
indices = Base.to_indices(t, I)
183180
for (k, v) in t.data

‎src/linalg/factorizations.jl‎

Lines changed: 47 additions & 48 deletions
Original file line numberDiff line numberDiff line change
@@ -1,22 +1,21 @@
11
using TensorKit: QR, QRpos, QL, QLpos, SVD, SDD, Polar, LQ, LQpos, RQ, RQpos
22

33
function TK.leftorth!(
4-
t::AbstractBlockTensorMap;
5-
alg::Union{QR,QRpos,QL,QLpos,SVD,SDD,Polar}=QRpos(),
6-
atol::Real=zero(float(real(scalartype(t)))),
7-
rtol::Real=if (alg ∉ (SVD(), SDD()))
8-
zero(float(real(scalartype(t))))
9-
else
10-
eps(real(float(one(scalartype(t))))) * iszero(atol)
11-
end,
12-
)
13-
InnerProductStyle(t) === EuclideanInnerProduct() ||
14-
throw_invalid_innerproduct(:leftorth!)
4+
t::AbstractBlockTensorMap;
5+
alg::Union{QR, QRpos, QL, QLpos, SVD, SDD, Polar} = QRpos(),
6+
atol::Real = zero(float(real(scalartype(t)))),
7+
rtol::Real = if (alg ∉ (SVD(), SDD()))
8+
zero(float(real(scalartype(t))))
9+
else
10+
eps(real(float(one(scalartype(t))))) * iszero(atol)
11+
end,
12+
)
13+
InnerProductStyle(t) === EuclideanInnerProduct() || throw_invalid_innerproduct(:leftorth!)
1514
if !iszero(rtol)
1615
atol = max(atol, rtol * norm(t))
1716
end
1817
I = sectortype(t)
19-
dims = TK.SectorDict{I,Int}()
18+
dims = TK.SectorDict{I, Int}()
2019

2120
# compute QR factorization for each block
2221
if !isempty(TK.blocks(t))
@@ -59,22 +58,22 @@ function TK.leftorth!(t::SparseBlockTensorMap; kwargs...)
5958
end
6059

6160
function TK.leftnull!(
62-
t::BlockTensorMap;
63-
alg::Union{QR,QRpos,SVD,SDD}=QRpos(),
64-
atol::Real=zero(float(real(scalartype(t)))),
65-
rtol::Real=if (alg ∉ (SVD(), SDD()))
66-
zero(float(real(scalartype(t))))
67-
else
68-
eps(real(float(one(scalartype(t))))) * iszero(atol)
69-
end,
70-
)
61+
t::BlockTensorMap;
62+
alg::Union{QR, QRpos, SVD, SDD} = QRpos(),
63+
atol::Real = zero(float(real(scalartype(t)))),
64+
rtol::Real = if (alg ∉ (SVD(), SDD()))
65+
zero(float(real(scalartype(t))))
66+
else
67+
eps(real(float(one(scalartype(t))))) * iszero(atol)
68+
end,
69+
)
7170
InnerProductStyle(t) === EuclideanInnerProduct() ||
7271
throw_invalid_innerproduct(:leftnull!)
7372
if !iszero(rtol)
7473
atol = max(atol, rtol * norm(t))
7574
end
7675
I = sectortype(t)
77-
dims = SectorDict{I,Int}()
76+
dims = SectorDict{I, Int}()
7877

7978
# compute QR factorization for each block
8079
V = codomain(t)
@@ -104,22 +103,22 @@ end
104103
TK.leftnull!(t::SparseBlockTensorMap; kwargs...) = leftnull!(BlockTensorMap(t); kwargs...)
105104

106105
function TK.rightorth!(
107-
t::AbstractBlockTensorMap;
108-
alg::Union{LQ,LQpos,RQ,RQpos,SVD,SDD,Polar}=LQpos(),
109-
atol::Real=zero(float(real(scalartype(t)))),
110-
rtol::Real=if (alg ∉ (SVD(), SDD()))
111-
zero(float(real(scalartype(t))))
112-
else
113-
eps(real(float(one(scalartype(t))))) * iszero(atol)
114-
end,
115-
)
106+
t::AbstractBlockTensorMap;
107+
alg::Union{LQ, LQpos, RQ, RQpos, SVD, SDD, Polar} = LQpos(),
108+
atol::Real = zero(float(real(scalartype(t)))),
109+
rtol::Real = if (alg ∉ (SVD(), SDD()))
110+
zero(float(real(scalartype(t))))
111+
else
112+
eps(real(float(one(scalartype(t))))) * iszero(atol)
113+
end,
114+
)
116115
InnerProductStyle(t) === EuclideanInnerProduct() ||
117116
throw_invalid_innerproduct(:rightorth!)
118117
if !iszero(rtol)
119118
atol = max(atol, rtol * norm(t))
120119
end
121120
I = sectortype(t)
122-
dims = TK.SectorDict{I,Int}()
121+
dims = TK.SectorDict{I, Int}()
123122

124123
# compute LQ factorization for each block
125124
if !isempty(TK.blocks(t))
@@ -162,22 +161,22 @@ function TK.rightorth!(t::SparseBlockTensorMap; kwargs...)
162161
end
163162

164163
function TK.rightnull!(
165-
t::BlockTensorMap;
166-
alg::Union{LQ,LQpos,SVD,SDD}=LQpos(),
167-
atol::Real=zero(float(real(scalartype(t)))),
168-
rtol::Real=if (alg ∉ (SVD(), SDD()))
169-
zero(float(real(scalartype(t))))
170-
else
171-
eps(real(float(one(scalartype(t))))) * iszero(atol)
172-
end,
173-
)
164+
t::BlockTensorMap;
165+
alg::Union{LQ, LQpos, SVD, SDD} = LQpos(),
166+
atol::Real = zero(float(real(scalartype(t)))),
167+
rtol::Real = if (alg ∉ (SVD(), SDD()))
168+
zero(float(real(scalartype(t))))
169+
else
170+
eps(real(float(one(scalartype(t))))) * iszero(atol)
171+
end,
172+
)
174173
InnerProductStyle(t) === EuclideanInnerProduct() ||
175174
throw_invalid_innerproduct(:rightnull!)
176175
if !iszero(rtol)
177176
atol = max(atol, rtol * norm(t))
178177
end
179178
I = sectortype(t)
180-
dims = SectorDict{I,Int}()
179+
dims = SectorDict{I, Int}()
181180

182181
# compute LQ factorization for each block
183182
V = domain(t)
@@ -206,16 +205,16 @@ function TK.rightnull!(
206205
end
207206
TK.rightnull!(t::SparseBlockTensorMap; kwargs...) = rightnull!(BlockTensorMap(t); kwargs...)
208207

209-
function TK.tsvd!(t::AbstractBlockTensorMap; trunc=TK.NoTruncation(), p::Real=2, alg=SDD())
208+
function TK.tsvd!(t::AbstractBlockTensorMap; trunc = TK.NoTruncation(), p::Real = 2, alg = SDD())
210209
return TK._tsvd!(t, alg, trunc, p)
211210
end
212211
function TK.tsvd!(t::SparseBlockTensorMap; kwargs...)
213212
return tsvd!(BlockTensorMap(t); kwargs...)
214213
end
215214

216215
function TK._tsvd!(
217-
t::BlockTensorMap, alg::Union{SVD,SDD}, trunc::TruncationScheme, p::Real=2
218-
)
216+
t::BlockTensorMap, alg::Union{SVD, SDD}, trunc::TruncationScheme, p::Real = 2
217+
)
219218
# early return
220219
if isempty(blocksectors(t))
221220
truncerr = zero(real(scalartype(t)))
@@ -234,10 +233,10 @@ function TK._tsvd!(
234233
return U, Σ, V⁺, truncerr
235234
end
236235

237-
function TK._compute_svddata!(t::AbstractBlockTensorMap, alg::Union{SVD,SDD})
236+
function TK._compute_svddata!(t::AbstractBlockTensorMap, alg::Union{SVD, SDD})
238237
InnerProductStyle(t) === EuclideanInnerProduct() || throw_invalid_innerproduct(:tsvd!)
239238
I = sectortype(t)
240-
dims = SectorDict{I,Int}()
239+
dims = SectorDict{I, Int}()
241240
generator = Base.Iterators.map(TK.blocks(t)) do (c, b)
242241
U, Σ, V = TK.MatrixAlgebra.svd!(b, alg)
243242
dims[c] = length(Σ)
@@ -266,7 +265,7 @@ function TK._empty_svdtensors(t::AbstractBlockTensorMap)
266265
T = scalartype(t)
267266
S = spacetype(t)
268267
I = sectortype(t)
269-
dims = SectorDict{I,Int}()
268+
dims = SectorDict{I, Int}()
270269
W = S(dims)
271270

272271
U = similar(t, codomain(t) ← W)

0 commit comments

Comments
 (0)