Skip to content

Commit 0ddadc2

Browse files
lkdvoslkdvos
committed
some cleanup
1 parent 2b0ccfc commit 0ddadc2

File tree

3 files changed

+8
-292
lines changed

3 files changed

+8
-292
lines changed

‎src/BlockTensorKit.jl‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -52,7 +52,6 @@ include("tensors/vectorinterface.jl")
5252
include("tensors/tensoroperations.jl")
5353

5454
include("linalg/linalg.jl")
55-
# include("linalg/matrixalgebra.jl")
5655
include("linalg/factorizations.jl")
5756

5857
include("auxiliary/sparsetensorarray.jl")

‎src/linalg/factorizations.jl‎

Lines changed: 8 additions & 265 deletions
Original file line numberDiff line numberDiff line change
@@ -118,268 +118,11 @@ function MAK.initialize_output(::typeof(svd_compact!), t::AbstractBlockTensorMap
118118
return U, S, Vᴴ
119119
end
120120

121-
# function TK.leftorth!(
122-
# t::AbstractBlockTensorMap;
123-
# alg::Union{QR, QRpos, QL, QLpos, SVD, SDD, Polar} = QRpos(),
124-
# atol::Real = zero(float(real(scalartype(t)))),
125-
# rtol::Real = if (alg ∉ (SVD(), SDD()))
126-
# zero(float(real(scalartype(t))))
127-
# else
128-
# eps(real(float(one(scalartype(t))))) * iszero(atol)
129-
# end,
130-
# )
131-
# InnerProductStyle(t) === EuclideanInnerProduct() || throw_invalid_innerproduct(:leftorth!)
132-
# if !iszero(rtol)
133-
# atol = max(atol, rtol * norm(t))
134-
# end
135-
# I = sectortype(t)
136-
# dims = TK.SectorDict{I, Int}()
137-
#
138-
# # compute QR factorization for each block
139-
# if !isempty(TK.blocks(t))
140-
# generator = Base.Iterators.map(TK.blocks(t)) do (c, b)
141-
# Qc, Rc = TK.MatrixAlgebra.leftorth!(b, alg, atol)
142-
# dims[c] = size(Qc, 2)
143-
# return c => (Qc, Rc)
144-
# end
145-
# QRdata = SectorDict(generator)
146-
# end
147-
#
148-
# # construct new space
149-
# S = spacetype(t)
150-
# V = S(dims)
151-
# if alg isa Polar
152-
# @assert V ≅ domain(t)
153-
# W = domain(t)
154-
# else
155-
# W = ProductSpace(V)
156-
# end
157-
#
158-
# # construct output tensors
159-
# T = float(scalartype(t))
160-
# Q = similar(t, T, codomain(t) ← W)
161-
# R = similar(t, T, W ← domain(t))
162-
# if !isempty(blocksectors(domain(t)))
163-
# for (c, (Qc, Rc)) in QRdata
164-
# block(Q, c) .= Qc
165-
# block(R, c) .= Rc
166-
# end
167-
# end
168-
# return Q, R
169-
# end
170-
# function TK.leftorth!(t::SparseBlockTensorMap; kwargs...)
171-
# return leftorth!(BlockTensorMap(t); kwargs...)
172-
# end
173-
#
174-
# function TK.leftnull!(
175-
# t::BlockTensorMap;
176-
# alg::Union{QR, QRpos, SVD, SDD} = QRpos(),
177-
# atol::Real = zero(float(real(scalartype(t)))),
178-
# rtol::Real = if (alg ∉ (SVD(), SDD()))
179-
# zero(float(real(scalartype(t))))
180-
# else
181-
# eps(real(float(one(scalartype(t))))) * iszero(atol)
182-
# end,
183-
# )
184-
# InnerProductStyle(t) === EuclideanInnerProduct() ||
185-
# throw_invalid_innerproduct(:leftnull!)
186-
# if !iszero(rtol)
187-
# atol = max(atol, rtol * norm(t))
188-
# end
189-
# I = sectortype(t)
190-
# dims = SectorDict{I, Int}()
191-
#
192-
# # compute QR factorization for each block
193-
# V = codomain(t)
194-
# if !isempty(blocksectors(V))
195-
# generator = Base.Iterators.map(blocksectors(V)) do c
196-
# Nc = MatrixAlgebra.leftnull!(block(t, c), alg, atol)
197-
# dims[c] = size(Nc, 2)
198-
# return c => Nc
199-
# end
200-
# Ndata = SectorDict(generator)
201-
# end
202-
#
203-
# # construct new space
204-
# S = spacetype(t)
205-
# W = S(dims)
206-
#
207-
# # construct output tensor
208-
# T = float(scalartype(t))
209-
# N = similar(t, T, V ← W)
210-
# if !isempty(blocksectors(V))
211-
# for (c, Nc) in Ndata
212-
# copy!(block(N, c), Nc)
213-
# end
214-
# end
215-
# return N
216-
# end
217-
# TK.leftnull!(t::SparseBlockTensorMap; kwargs...) = leftnull!(BlockTensorMap(t); kwargs...)
218-
#
219-
# function TK.rightorth!(
220-
# t::AbstractBlockTensorMap;
221-
# alg::Union{LQ, LQpos, RQ, RQpos, SVD, SDD, Polar} = LQpos(),
222-
# atol::Real = zero(float(real(scalartype(t)))),
223-
# rtol::Real = if (alg ∉ (SVD(), SDD()))
224-
# zero(float(real(scalartype(t))))
225-
# else
226-
# eps(real(float(one(scalartype(t))))) * iszero(atol)
227-
# end,
228-
# )
229-
# InnerProductStyle(t) === EuclideanInnerProduct() ||
230-
# throw_invalid_innerproduct(:rightorth!)
231-
# if !iszero(rtol)
232-
# atol = max(atol, rtol * norm(t))
233-
# end
234-
# I = sectortype(t)
235-
# dims = TK.SectorDict{I, Int}()
236-
#
237-
# # compute LQ factorization for each block
238-
# if !isempty(TK.blocks(t))
239-
# generator = Base.Iterators.map(TK.blocks(t)) do (c, b)
240-
# Lc, Qc = TK.MatrixAlgebra.rightorth!(b, alg, atol)
241-
# dims[c] = size(Qc, 1)
242-
# return c => (Lc, Qc)
243-
# end
244-
# LQdata = SectorDict(generator)
245-
# end
246-
#
247-
# # construct new space
248-
# S = spacetype(t)
249-
# V = S(dims)
250-
# if alg isa Polar
251-
# @assert V ≅ codomain(t)
252-
# W = codomain(t)
253-
# else
254-
# W = ProductSpace(V)
255-
# end
256-
#
257-
# # construct output tensors
258-
# T = float(scalartype(t))
259-
# L = similar(t, T, codomain(t) ← W)
260-
# Q = similar(t, T, W ← domain(t))
261-
# if !isempty(blocksectors(codomain(t)))
262-
# for (c, (Lc, Qc)) in LQdata
263-
# block(L, c) .= Lc
264-
# block(Q, c) .= Qc
265-
# end
266-
# end
267-
# return L, Q
268-
# end
269-
# function TK.rightorth!(t::SparseBlockTensorMap; kwargs...)
270-
# return rightorth!(BlockTensorMap(t); kwargs...)
271-
# end
272-
#
273-
# function TK.rightnull!(
274-
# t::BlockTensorMap;
275-
# alg::Union{LQ, LQpos, SVD, SDD} = LQpos(),
276-
# atol::Real = zero(float(real(scalartype(t)))),
277-
# rtol::Real = if (alg ∉ (SVD(), SDD()))
278-
# zero(float(real(scalartype(t))))
279-
# else
280-
# eps(real(float(one(scalartype(t))))) * iszero(atol)
281-
# end,
282-
# )
283-
# InnerProductStyle(t) === EuclideanInnerProduct() ||
284-
# throw_invalid_innerproduct(:rightnull!)
285-
# if !iszero(rtol)
286-
# atol = max(atol, rtol * norm(t))
287-
# end
288-
# I = sectortype(t)
289-
# dims = SectorDict{I, Int}()
290-
#
291-
# # compute LQ factorization for each block
292-
# V = domain(t)
293-
# if !isempty(blocksectors(V))
294-
# generator = Base.Iterators.map(blocksectors(V)) do c
295-
# Nc = MatrixAlgebra.rightnull!(block(t, c), alg, atol)
296-
# dims[c] = size(Nc, 1)
297-
# return c => Nc
298-
# end
299-
# Ndata = SectorDict(generator)
300-
# end
301-
#
302-
# # construct new space
303-
# S = spacetype(t)
304-
# W = S(dims)
305-
#
306-
# # construct output tensor
307-
# T = float(scalartype(t))
308-
# N = similar(t, T, W ← V)
309-
# if !isempty(blocksectors(V))
310-
# for (c, Nc) in Ndata
311-
# copy!(block(N, c), Nc)
312-
# end
313-
# end
314-
# return N
315-
# end
316-
# TK.rightnull!(t::SparseBlockTensorMap; kwargs...) = rightnull!(BlockTensorMap(t); kwargs...)
317-
#
318-
# function TK.tsvd!(t::AbstractBlockTensorMap; trunc = TK.NoTruncation(), p::Real = 2, alg = SDD())
319-
# return TK._tsvd!(t, alg, trunc, p)
320-
# end
321-
# function TK.tsvd!(t::SparseBlockTensorMap; kwargs...)
322-
# return tsvd!(BlockTensorMap(t); kwargs...)
323-
# end
324-
#
325-
# function TK._tsvd!(
326-
# t::BlockTensorMap, alg::Union{SVD, SDD}, trunc::TruncationScheme, p::Real = 2
327-
# )
328-
# # early return
329-
# if isempty(blocksectors(t))
330-
# truncerr = zero(real(scalartype(t)))
331-
# return TK._empty_svdtensors(t)..., truncerr
332-
# end
333-
#
334-
# # compute SVD factorization for each block
335-
# S = spacetype(t)
336-
# SVDdata, dims = TK._compute_svddata!(t, alg)
337-
# Σdata = SectorDict(c => Σ for (c, (U, Σ, V)) in SVDdata)
338-
# truncdim = TK._compute_truncdim(Σdata, trunc, p)
339-
# truncerr = TK._compute_truncerr(Σdata, truncdim, p)
340-
#
341-
# # construct output tensors
342-
# U, Σ, V⁺ = TK._create_svdtensors(t, SVDdata, truncdim)
343-
# return U, Σ, V⁺, truncerr
344-
# end
345-
#
346-
# function TK._compute_svddata!(t::AbstractBlockTensorMap, alg::Union{SVD, SDD})
347-
# InnerProductStyle(t) === EuclideanInnerProduct() || throw_invalid_innerproduct(:tsvd!)
348-
# I = sectortype(t)
349-
# dims = SectorDict{I, Int}()
350-
# generator = Base.Iterators.map(TK.blocks(t)) do (c, b)
351-
# U, Σ, V = TK.MatrixAlgebra.svd!(b, alg)
352-
# dims[c] = length(Σ)
353-
# return c => (U, Σ, V)
354-
# end
355-
# SVDdata = SectorDict(generator)
356-
# return SVDdata, dims
357-
# end
358-
# function TK._create_svdtensors(t::AbstractBlockTensorMap, SVDdata, dims)
359-
# S = spacetype(t)
360-
# W = S(dims)
361-
# T = float(scalartype(t))
362-
# U = similar(t, T, codomain(t) ← W)
363-
# Σ = similar(t, real(T), W ← W)
364-
# V⁺ = similar(t, T, W ← domain(t))
365-
# for (c, (Uc, Σc, V⁺c)) in SVDdata
366-
# r = Base.OneTo(dims[c])
367-
# block(U, c) .= view(Uc, :, r)
368-
# block(Σ, c) .= Diagonal(view(Σc, r))
369-
# block(V⁺, c) .= view(V⁺c, r, :)
370-
# end
371-
# return U, Σ, V⁺
372-
# end
373-
#
374-
# function TK._empty_svdtensors(t::AbstractBlockTensorMap)
375-
# T = scalartype(t)
376-
# S = spacetype(t)
377-
# I = sectortype(t)
378-
# dims = SectorDict{I, Int}()
379-
# W = S(dims)
380-
#
381-
# U = similar(t, codomain(t) ← W)
382-
# Σ = similar(t, real(T), W ← W)
383-
# V⁺ = similar(t, W ← domain(t))
384-
# return U, Σ, V⁺
385-
# end
121+
# Disambiguate Diagonal implementations
122+
# -------------------------------------
123+
# these shouldn't ever happen as blocktensors aren't diagonal
124+
for f! in (:eig_full!, :eigh_full!, :lq_compact!, :lq_full!, :qr_compact!, :qr_full!, :svd_full!)
125+
@eval function MAK.initialize_output(::typeof($f!), t::AbstractBlockTensorMap, alg::DiagonalAlgorithm)
126+
error("Blocktensors are incompatible with diagonal algorithm")
127+
end
128+
end

‎src/linalg/matrixalgebra.jl‎

Lines changed: 0 additions & 26 deletions
This file was deleted.

0 commit comments

Comments
 (0)