diff --git a/src/spaces/homspace.jl b/src/spaces/homspace.jl index f1819572e..6e5153e83 100644 --- a/src/spaces/homspace.jl +++ b/src/spaces/homspace.jl @@ -211,7 +211,7 @@ according to the permutation `p₁` and `p₂` respectively. function permute(W::HomSpace, (p₁, p₂)::Index2Tuple) p = (p₁..., p₂...) TupleTools.isperm(p) && length(p) == numind(W) || - throw(ArgumentError("$((p₁, p₂)) is not a valid permutation for $(W)")) + throw(ArgumentError(lazy"$((p₁, p₂)) is not a valid permutation for $(W)")) return select(W, (p₁, p₂)) end @@ -226,7 +226,7 @@ end function braid(W::HomSpace, (p₁, p₂)::Index2Tuple, levels::IndexTuple) p = (p₁..., p₂...) TupleTools.isperm(p) && length(p) == numind(W) == length(levels) || - throw(ArgumentError("$((p₁, p₂)), $levels is not a valid braiding for $(W)")) + throw(ArgumentError(lazy"$((p₁, p₂)), $levels is not a valid braiding for $(W)")) return select(W, (p₁, p₂)) end @@ -265,7 +265,7 @@ Obtain the HomSpace that is obtained from composing the morphisms in `W` and `V` to be possible, the domain of `W` must match the codomain of `V`. """ function compose(W::HomSpace{S}, V::HomSpace{S}) where {S} - domain(W) == codomain(V) || throw(SpaceMismatch("$(domain(W)) ≠ $(codomain(V))")) + domain(W) == codomain(V) || throw(SpaceMismatch(lazy"$(domain(W)) ≠ $(codomain(V))")) return HomSpace(codomain(W), domain(V)) end diff --git a/src/tensors/treetransformers.jl b/src/tensors/treetransformers.jl index aaecbe746..86b9c926e 100644 --- a/src/tensors/treetransformers.jl +++ b/src/tensors/treetransformers.jl @@ -36,7 +36,7 @@ function AbelianTreeTransformer(transform, p, Vdst, Vsrc) Δt = Base.time() - t₀ - @debug("Treetransformer for $Vsrc to $Vdst via $p", nblocks = L, Δt) + @debug(lazy"Treetransformer for $Vsrc to $Vdst via $p", nblocks = L, Δt) return transformer end @@ -81,7 +81,7 @@ function GenericTreeTransformer(transform, p, Vdst, Vsrc) data[local_counter] = U, (sz_dst, newstructs_dst), (sz_src, newstructs_src) @debug( - "Created recoupling block for uncoupled: $(fs_src.uncoupled)", + lazy"Created recoupling block for uncoupled: $(fs_src.uncoupled)", sz = size(U), sparsity = count(!iszero, U) / length(U) ) end @@ -96,7 +96,7 @@ function GenericTreeTransformer(transform, p, Vdst, Vsrc) data[i] = U, (sz_dst, newstructs_dst), (sz_src, newstructs_src) @debug( - "Created recoupling block for uncoupled: $(fs_src.uncoupled)", + lazy"Created recoupling block for uncoupled: $(fs_src.uncoupled)", sz = size(U), sparsity = count(!iszero, U) / length(U) ) end @@ -109,7 +109,7 @@ function GenericTreeTransformer(transform, p, Vdst, Vsrc) Δt = Base.time() - t₀ @debug( - "TreeTransformer for $Vsrc to $Vdst via $p", + lazy"TreeTransformer for $Vsrc to $Vdst via $p", nblocks = length(transformer.data), sz_median = size(transformer.data[cld(end, 2)][1], 1), sz_max = size(transformer.data[1][1], 1), diff --git a/src/tensors/vectorinterface.jl b/src/tensors/vectorinterface.jl index 88c2cb5fb..460000787 100644 --- a/src/tensors/vectorinterface.jl +++ b/src/tensors/vectorinterface.jl @@ -41,14 +41,14 @@ function VectorInterface.scale!!(t::AbstractTensorMap, α::Number) return T <: scalartype(t) ? scale!(t, α) : scale(t, α) end function VectorInterface.scale!(ty::AbstractTensorMap, tx::AbstractTensorMap, α::Number) - space(ty) == space(tx) || throw(SpaceMismatch("$(space(ty)) ≠ $(space(tx))")) + space(ty) == space(tx) || throw(SpaceMismatch(lazy"$(space(ty)) ≠ $(space(tx))")) for ((cy, by), (cx, bx)) in zip(blocks(ty), blocks(tx)) scale!(by, bx, α) end return ty end function VectorInterface.scale!(ty::TensorMap, tx::TensorMap, α::Number) - space(ty) == space(tx) || throw(SpaceMismatch("$(space(ty)) ≠ $(space(tx))")) + space(ty) == space(tx) || throw(SpaceMismatch(lazy"$(space(ty)) ≠ $(space(tx))")) scale!(ty.data, tx.data, α) return ty end @@ -66,7 +66,7 @@ end # TODO: remove VectorInterface from calls to `add!` when `TensorKit.add!` is renamed function VectorInterface.add(ty::AbstractTensorMap, tx::AbstractTensorMap, α::Number, β::Number) S = check_spacetype(ty, tx) - space(ty) == space(tx) || throw(SpaceMismatch("$(space(ty)) ≠ $(space(tx))")) + space(ty) == space(tx) || throw(SpaceMismatch(lazy"$(space(ty)) ≠ $(space(tx))")) # result type defaults to TensorMap if the types don't match to avoid assymmetric # implementation via zerovector(ty, T) vs zerovector(tx, T) @@ -84,7 +84,7 @@ end function VectorInterface.add!( ty::AbstractTensorMap, tx::AbstractTensorMap, α::Number, β::Number ) - space(ty) == space(tx) || throw(SpaceMismatch("$(space(ty)) ≠ $(space(tx))")) + space(ty) == space(tx) || throw(SpaceMismatch(lazy"$(space(ty)) ≠ $(space(tx))")) for ((cy, by), (cx, bx)) in zip(blocks(ty), blocks(tx)) add!(by, bx, α, β) end @@ -93,7 +93,7 @@ end function VectorInterface.add!( ty::TensorMap, tx::TensorMap, α::Number, β::Number ) - space(ty) == space(tx) || throw(SpaceMismatch("$(space(ty)) ≠ $(space(tx))")) + space(ty) == space(tx) || throw(SpaceMismatch(lazy"$(space(ty)) ≠ $(space(tx))")) add!(ty.data, tx.data, α, β) return ty end @@ -112,7 +112,7 @@ end # inner #------- function VectorInterface.inner(tx::AbstractTensorMap, ty::AbstractTensorMap) - space(tx) == space(ty) || throw(SpaceMismatch("$(space(tx)) ≠ $(space(ty))")) + space(tx) == space(ty) || throw(SpaceMismatch(lazy"$(space(tx)) ≠ $(space(ty))")) InnerProductStyle(tx) === EuclideanInnerProduct() || throw_invalid_innerproduct(:inner) T = VectorInterface.promote_inner(tx, ty) s = zero(T) @@ -122,7 +122,7 @@ function VectorInterface.inner(tx::AbstractTensorMap, ty::AbstractTensorMap) return s end function VectorInterface.inner(tx::TensorMap, ty::TensorMap) - space(tx) == space(ty) || throw(SpaceMismatch("$(space(tx)) ≠ $(space(ty))")) + space(tx) == space(ty) || throw(SpaceMismatch(lazy"$(space(tx)) ≠ $(space(ty))")) InnerProductStyle(tx) === EuclideanInnerProduct() || throw_invalid_innerproduct(:inner) if FusionStyle(sectortype(tx)) isa UniqueFusion # all quantum dimensions are one return inner(tx.data, ty.data)