remove unused constructors

[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: lkdvos

src/fusedgradedmatrix.jl

@@ -86,51 +86,6 @@ function FusedGradedMatrix(
     return FusedGradedMatrix(cod, dom, blks)
 end
 
-function FusedGradedMatrix(pairs::AbstractVector{<:Pair{<:SectorRange}})
-    return FusedGradedMatrix(first.(pairs), last.(pairs))
-end
-
-# ========================  undef constructors  ========================
-
-# Symmetric `undef` constructor: same sector list on both axes.
-function FusedGradedMatrix{T, D, S}(
-        ::UndefInitializer,
-        sectors::AbstractVector{S},
-        axes::Tuple{BlockedOneTo, BlockedOneTo}
-    ) where {T, D <: AbstractMatrix{T}, S <: SectorRange}
-    blocklength(axes[1]) == blocklength(axes[2]) == length(sectors) ||
-        throw(ArgumentError("axes block counts must match sectors length"))
-    issorted(sectors) || throw(ArgumentError("sectors must be sorted"))
-    allunique(sectors) || throw(ArgumentError("sectors must be unique"))
-    cod = Dictionary{S, Int}(sectors, map(length, eachblockaxis(axes[1])))
-    dom = Dictionary{S, Int}(sectors, map(length, eachblockaxis(axes[2])))
-    return FusedGradedMatrix{T, D, S}(undef, cod, dom)
-end
-
-# Convenience: default D = Matrix{T}.
-function FusedGradedMatrix{T}(
-        ::UndefInitializer, sectors::AbstractVector{<:SectorRange},
-        axes::Tuple{BlockedOneTo, BlockedOneTo}
-    ) where {T}
-    S = eltype(sectors)
-    return FusedGradedMatrix{T, Matrix{T}, S}(undef, sectors, axes)
-end
-
-# Vector{Int} convenience: wraps into BlockedOneTo and delegates.
-function FusedGradedMatrix{T}(
-        ::UndefInitializer,
-        sectors::AbstractVector{<:SectorRange},
-        codomain_blocklengths::AbstractVector{Int},
-        domain_blocklengths::AbstractVector{Int}
-    ) where {T}
-    S = eltype(sectors)
-    issorted(sectors) || throw(ArgumentError("sectors must be sorted"))
-    allunique(sectors) || throw(ArgumentError("sectors must be unique"))
-    cod = Dictionary{S, Int}(sectors, codomain_blocklengths)
-    dom = Dictionary{S, Int}(sectors, domain_blocklengths)
-    return FusedGradedMatrix{T}(undef, cod, dom)
-end
-
 function FusedGradedMatrix{T}(
         ::UndefInitializer, codomain::Dictionary{S, Int}, domain::Dictionary{S, Int}
     ) where {T, S <: SectorRange}
@@ -363,9 +318,6 @@ end
 
 # ========================  Conversion from AbelianGradedArray  ========================
 
-# Identity
-FusedGradedMatrix(m::FusedGradedMatrix) = m
-
 """
     FusedGradedMatrix(a::AbelianGradedMatrix{T})
 

src/fusedgradedvector.jl

@@ -142,44 +142,6 @@ function FusedGradedVector(
     return FusedGradedVector(ax, blks)
 end
 
-function FusedGradedVector(pairs::AbstractVector{<:Pair{<:SectorRange}})
-    return FusedGradedVector(first.(pairs), last.(pairs))
-end
-
-# ========================  undef constructors  ========================
-
-function FusedGradedVector{T, D, S}(
-        ::UndefInitializer,
-        sectors::AbstractVector{S},
-        ax::BlockedOneTo
-    ) where {T, D <: AbstractVector{T}, S <: SectorRange}
-    blocklength(ax) == length(sectors) ||
-        throw(ArgumentError("axis block count must match sectors length"))
-    issorted(sectors) || throw(ArgumentError("sectors must be sorted"))
-    allunique(sectors) || throw(ArgumentError("sectors must be unique"))
-    axis = Dictionary{S, Int}(sectors, map(length, eachblockaxis(ax)))
-    return FusedGradedVector{T, D, S}(undef, axis)
-end
-
-function FusedGradedVector{T}(
-        ::UndefInitializer, sectors::AbstractVector{<:SectorRange}, ax::BlockedOneTo
-    ) where {T}
-    S = eltype(sectors)
-    return FusedGradedVector{T, Vector{T}, S}(undef, sectors, ax)
-end
-
-function FusedGradedVector{T}(
-        ::UndefInitializer,
-        sectors::AbstractVector{<:SectorRange},
-        blocklengths::AbstractVector{Int}
-    ) where {T}
-    S = eltype(sectors)
-    issorted(sectors) || throw(ArgumentError("sectors must be sorted"))
-    allunique(sectors) || throw(ArgumentError("sectors must be unique"))
-    axis = Dictionary{S, Int}(sectors, blocklengths)
-    return FusedGradedVector{T}(undef, axis)
-end
-
 function FusedGradedVector{T}(
         ::UndefInitializer, axis::Dictionary{S, Int}
     ) where {T, S <: SectorRange}
@@ -331,31 +293,3 @@ function LinearAlgebra.norm(A::FusedGradedVector, p::Real = 2)
         throw(ArgumentError("Norm with non-positive p ($p) is not defined"))
     end
 end
-
-# ========================  Conversion from AbelianGradedArray  ========================
-
-# Identity
-FusedGradedVector(v::FusedGradedVector) = v
-
-"""
-    FusedGradedVector(a::AbelianGradedVector{T})
-
-Convert a 1D block-sparse `AbelianGradedArray` into a `FusedGradedVector`.
-The axis dict comes from the axis sectors and lengths; stored entries of `a`
-populate `blocks`.
-"""
-function FusedGradedVector(a::AbelianGradedVector{T}) where {T}
-    S = sectortype(a)
-    ax_sectors = sectors(axes(a, 1))
-    issorted(ax_sectors) ||
-        throw(ArgumentError("axis sectors of input must be sorted"))
-    allunique(ax_sectors) ||
-        throw(ArgumentError("axis sectors of input must be unique"))
-    axis = Dictionary{S, Int}(ax_sectors, datalengths(axes(a, 1)))
-
-    v = FusedGradedVector{T, datatype(a), S}(undef, axis)
-    for I in eachblockstoredindex(a)
-        view(v, I) .= view(a, I)
-    end
-    return v
-end

test/test_abelianarray.jl

@@ -1,4 +1,4 @@
-using BlockArrays: BlockArrays, Block, blockedrange, blocklength
+using BlockArrays: BlockArrays, Block, blocklength
 using BlockSparseArrays: eachblockstoredindex
 using Dictionaries: Dictionary
 using GradedArrays: GradedArrays, AbelianGradedArray, AbelianSectorArray,
@@ -216,8 +216,8 @@ using Test: @test, @test_throws, @testset
     end
 end
 
-@testset "FusedGradedMatrix Pair constructor" begin
-    m = FusedGradedMatrix([U1(0) => [1.0 2.0; 3.0 4.0], U1(1) => ones(3, 3)])
+@testset "FusedGradedMatrix sectors/blocks constructor" begin
+    m = FusedGradedMatrix([U1(0), U1(1)], [[1.0 2.0; 3.0 4.0], ones(3, 3)])
     @test m isa FusedGradedMatrix{Float64}
     @test data(m[Block(1, 1)]) == [1.0 2.0; 3.0 4.0]
     @test data(m[Block(2, 2)]) == ones(3, 3)
@@ -226,11 +226,8 @@ end
     # dimension `2j + 1`, so `Block(k, k)` has size
     # `(sectorlength × datalength)^2`.
     m_su2 = FusedGradedMatrix(
-        [
-            SU2(0) => [1.0;;],
-            SU2(1 // 2) => [1.0 2.0; 3.0 4.0],
-            SU2(1) => Matrix{Float64}(LinearAlgebra.I, 3, 3),
-        ]
+        [SU2(0), SU2(1 // 2), SU2(1)],
+        [[1.0;;], [1.0 2.0; 3.0 4.0], Matrix{Float64}(LinearAlgebra.I, 3, 3)]
     )
     @test m_su2 isa FusedGradedMatrix{Float64, Matrix{Float64}, SU2}
     @test collect(keys(m_su2.blocks)) == [SU2(0), SU2(1 // 2), SU2(1)]
@@ -242,75 +239,51 @@ end
 
 @testset "FusedGradedMatrix * FusedGradedMatrix" begin
     @testset "U1 (abelian)" begin
-        a = FusedGradedMatrix([U1(0) => [2.0;;], U1(1) => [1.0 2.0; 3.0 4.0]])
-        b = FusedGradedMatrix([U1(0) => [3.0;;], U1(1) => [0.0 1.0; 1.0 0.0]])
+        a = FusedGradedMatrix([U1(0), U1(1)], [[2.0;;], [1.0 2.0; 3.0 4.0]])
+        b = FusedGradedMatrix([U1(0), U1(1)], [[3.0;;], [0.0 1.0; 1.0 0.0]])
         c = a * b
         @test collect(keys(c.blocks)) == [U1(0), U1(1)]
         @test data(c[Block(1, 1)]) == [6.0;;]
         @test data(c[Block(2, 2)]) == [1.0 2.0; 3.0 4.0] * [0.0 1.0; 1.0 0.0]
     end
     @testset "SU2 (non-abelian)" begin
-        a = FusedGradedMatrix([SU2(0) => [2.0;;], SU2(1 // 2) => [1.0 2.0; 3.0 4.0]])
-        b = FusedGradedMatrix([SU2(0) => [3.0;;], SU2(1 // 2) => [0.0 1.0; 1.0 0.0]])
+        a = FusedGradedMatrix([SU2(0), SU2(1 // 2)], [[2.0;;], [1.0 2.0; 3.0 4.0]])
+        b = FusedGradedMatrix([SU2(0), SU2(1 // 2)], [[3.0;;], [0.0 1.0; 1.0 0.0]])
         c = a * b
         @test collect(keys(c.blocks)) == [SU2(0), SU2(1 // 2)]
         @test data(c[Block(1, 1)]) == [6.0;;]
         @test data(c[Block(2, 2)]) == [1.0 2.0; 3.0 4.0] * [0.0 1.0; 1.0 0.0]
     end
     @testset "mismatched sectors throws" begin
-        a = FusedGradedMatrix([U1(0) => [2.0;;], U1(1) => [1.0 2.0; 3.0 4.0]])
-        b = FusedGradedMatrix([U1(0) => [3.0;;]])
+        a = FusedGradedMatrix([U1(0), U1(1)], [[2.0;;], [1.0 2.0; 3.0 4.0]])
+        b = FusedGradedMatrix([U1(0)], [[3.0;;]])
         @test_throws DimensionMismatch a * b
     end
 end
 
 @testset "FusedGradedMatrix undef constructor" begin
     sectors = [U1(0), U1(1)]
-    cod_bls = [2, 3]
-    dom_bls = [1, 2]
+    cod = Dictionary{U1, Int}(sectors, [2, 3])
+    dom = Dictionary{U1, Int}(sectors, [1, 2])
 
-    @testset "Convenience constructor (defaults D = Matrix{T})" begin
-        m = FusedGradedMatrix{Float64}(undef, sectors, cod_bls, dom_bls)
+    @testset "Default D = Matrix{T}" begin
+        m = FusedGradedMatrix{Float64}(undef, cod, dom)
         @test m isa FusedGradedMatrix{Float64, Matrix{Float64}, U1}
         @test length(m.blocks) == 2
         @test collect(keys(m.blocks)) == sectors
         @test size(m.blocks[U1(0)]) == (2, 1)
         @test size(m.blocks[U1(1)]) == (3, 2)
     end
 
-    @testset "Fully parameterized constructor" begin
-        m = FusedGradedMatrix{Float64, Matrix{Float64}, U1}(
-            undef, sectors, (blockedrange(cod_bls), blockedrange(dom_bls))
-        )
+    @testset "Fully parameterized" begin
+        m = FusedGradedMatrix{Float64, Matrix{Float64}, U1}(undef, cod, dom)
         @test m isa FusedGradedMatrix{Float64, Matrix{Float64}, U1}
         @test size(m.blocks[U1(0)]) == (2, 1)
     end
 
-    @testset "Tuple BlockedOneTo form" begin
-        m = FusedGradedMatrix{Float64}(
-            undef, sectors, (blockedrange([2, 3]), blockedrange([1, 2]))
-        )
-        @test m isa FusedGradedMatrix{Float64, Matrix{Float64}, U1}
-        @test size(m.blocks[U1(0)]) == (2, 1)
-        @test size(m.blocks[U1(1)]) == (3, 2)
-    end
-
-    @testset "Rejects mismatched lengths" begin
-        @test_throws Exception FusedGradedMatrix{Float64}(
-            undef, sectors, cod_bls, [1]
-        )
-    end
-
     @testset "Rejects unsorted sectors" begin
-        @test_throws ArgumentError FusedGradedMatrix{Float64}(
-            undef, [U1(1), U1(0)], cod_bls, dom_bls
-        )
-    end
-
-    @testset "Rejects non-unique sectors" begin
-        @test_throws ArgumentError FusedGradedMatrix{Float64}(
-            undef, [U1(0), U1(0)], [2, 3], [1, 2]
-        )
+        cod_bad = Dictionary{U1, Int}([U1(1), U1(0)], [2, 3])
+        @test_throws ArgumentError FusedGradedMatrix{Float64}(undef, cod_bad, dom)
     end
 end