Automatic ITensorFormatter run

Project.toml

@@ -1,6 +1,6 @@
 name = "DiagonalArrays"
 uuid = "74fd4be6-21e2-4f6f-823a-4360d37c7a77"
-version = "0.3.32"
+version = "0.3.33"
 authors = ["ITensor developers <support@itensor.org> and contributors"]
 
 [workspace]

README.md

@@ -45,7 +45,7 @@ julia> Pkg.add("DiagonalArrays")
 
 ````julia
 using DiagonalArrays:
-    DiagonalArray, DiagonalMatrix, DiagIndex, DiagIndices, diaglength, isdiagindex
+    DiagIndex, DiagIndices, DiagonalArray, DiagonalMatrix, diaglength, isdiagindex
 using Test: @test
 
 function main()

benchmark/benchmarks.jl

@@ -1,5 +1,5 @@
-using DiagonalArrays
 using BenchmarkTools
+using DiagonalArrays
 
 SUITE = BenchmarkGroup()
 SUITE["rand"] = @benchmarkable rand(10)

docs/make.jl

@@ -1,7 +1,12 @@
 using DiagonalArrays: DiagonalArrays
 using Documenter: Documenter, DocMeta, deploydocs, makedocs
 
-DocMeta.setdocmeta!(DiagonalArrays, :DocTestSetup, :(using DiagonalArrays); recursive = true)
+DocMeta.setdocmeta!(
+    DiagonalArrays,
+    :DocTestSetup,
+    :(using DiagonalArrays);
+    recursive = true
+)
 
 include("make_index.jl")
 
@@ -12,9 +17,9 @@ makedocs(;
     format = Documenter.HTML(;
         canonical = "https://itensor.github.io/DiagonalArrays.jl",
         edit_link = "main",
-        assets = ["assets/favicon.ico", "assets/extras.css"],
+        assets = ["assets/favicon.ico", "assets/extras.css"]
     ),
-    pages = ["Home" => "index.md", "Reference" => "reference.md"],
+    pages = ["Home" => "index.md", "Reference" => "reference.md"]
 )
 
 deploydocs(;

docs/make_index.jl

@@ -1,5 +1,5 @@
-using Literate: Literate
 using DiagonalArrays: DiagonalArrays
+using Literate: Literate
 
 function ccq_logo(content)
     include_ccq_logo = """
@@ -17,5 +17,5 @@ Literate.markdown(
     joinpath(pkgdir(DiagonalArrays), "docs", "src");
     flavor = Literate.DocumenterFlavor(),
     name = "index",
-    postprocess = ccq_logo,
+    postprocess = ccq_logo
 )

docs/make_readme.jl

@@ -1,5 +1,5 @@
-using Literate: Literate
 using DiagonalArrays: DiagonalArrays
+using Literate: Literate
 
 function ccq_logo(content)
     include_ccq_logo = """
@@ -17,5 +17,5 @@ Literate.markdown(
     joinpath(pkgdir(DiagonalArrays));
     flavor = Literate.CommonMarkFlavor(),
     name = "README",
-    postprocess = ccq_logo,
+    postprocess = ccq_logo
 )

examples/README.jl

@@ -46,7 +46,7 @@ julia> Pkg.add("DiagonalArrays")
 # ## Examples
 
 using DiagonalArrays:
-    DiagonalArray, DiagonalMatrix, DiagIndex, DiagIndices, diaglength, isdiagindex
+    DiagIndex, DiagIndices, DiagonalArray, DiagonalMatrix, diaglength, isdiagindex
 using Test: @test
 
 function main()

ext/DiagonalArraysMatrixAlgebraKitExt/DiagonalArraysMatrixAlgebraKitExt.jl

@@ -1,54 +1,14 @@
 module DiagonalArraysMatrixAlgebraKitExt
 
-using DiagonalArrays:
-    AbstractDiagonalMatrix,
-    DeltaMatrix,
-    DiagonalMatrix,
-    ScaledDeltaMatrix,
-    δ,
-    diagview,
-    dual,
-    issquare
+using DiagonalArrays: AbstractDiagonalMatrix, DeltaMatrix, DiagonalMatrix,
+    ScaledDeltaMatrix, diagview, dual, issquare, δ
 using LinearAlgebra: LinearAlgebra, isdiag, ishermitian
-using MatrixAlgebraKit:
-    MatrixAlgebraKit,
-    AbstractAlgorithm,
-    check_input,
-    default_qr_algorithm,
-    eig_full,
-    eig_full!,
-    eig_vals,
-    eig_vals!,
-    eigh_full,
-    eigh_full!,
-    eigh_vals,
-    eigh_vals!,
-    left_null,
-    left_null!,
-    left_orth,
-    left_orth!,
-    left_polar,
-    left_polar!,
-    lq_compact,
-    lq_compact!,
-    lq_full,
-    lq_full!,
-    qr_compact,
-    qr_compact!,
-    qr_full,
-    qr_full!,
-    right_null,
-    right_null!,
-    right_orth,
-    right_orth!,
-    right_polar,
-    right_polar!,
-    svd_compact,
-    svd_compact!,
-    svd_full,
-    svd_full!,
-    svd_vals,
-    svd_vals!
+using MatrixAlgebraKit: MatrixAlgebraKit, AbstractAlgorithm, check_input,
+    default_qr_algorithm, eig_full, eig_full!, eig_vals, eig_vals!, eigh_full, eigh_full!,
+    eigh_vals, eigh_vals!, left_null, left_null!, left_orth, left_orth!, left_polar,
+    left_polar!, lq_compact, lq_compact!, lq_full, lq_full!, qr_compact, qr_compact!,
+    qr_full, qr_full!, right_null, right_null!, right_orth, right_orth!, right_polar,
+    right_polar!, svd_compact, svd_compact!, svd_full, svd_full!, svd_vals, svd_vals!
 
 abstract type AbstractDiagonalAlgorithm <: AbstractAlgorithm end
 

ext/DiagonalArraysNamedDimsArraysExt/DiagonalArraysNamedDimsArraysExt.jl

@@ -1,18 +1,18 @@
 module DiagonalArraysNamedDimsArraysExt
 
-using DiagonalArrays: DiagonalArrays, δ, delta
+using DiagonalArrays: DiagonalArrays, delta, δ
 using NamedDimsArrays: AbstractNamedUnitRange, denamed, name, nameddims
 
 function DiagonalArrays.delta(
         elt::Type{<:Number},
-        is::Tuple{AbstractNamedUnitRange, Vararg{AbstractNamedUnitRange}},
+        is::Tuple{AbstractNamedUnitRange, Vararg{AbstractNamedUnitRange}}
     )
     return nameddims(delta(elt, length.(denamed.(is))), name.(is))
 end
 # TODO: Make `δ` an alias for `delta` so this isn't needed.
 function DiagonalArrays.δ(
         elt::Type{<:Number},
-        is::Tuple{AbstractNamedUnitRange, Vararg{AbstractNamedUnitRange}},
+        is::Tuple{AbstractNamedUnitRange, Vararg{AbstractNamedUnitRange}}
     )
     return delta(elt, is)
 end

src/abstractdiagonalarray/diagonalarraydiaginterface.jl

@@ -5,7 +5,8 @@ diagview(a::AbstractDiagonalArray) = throw(MethodError(diagview, Tuple{typeof(a)
 using FunctionImplementations: FunctionImplementations
 using SparseArraysBase: SparseArraysBase as SA, AbstractSparseArrayImplementationStyle
 
-abstract type AbstractDiagonalArrayImplementationStyle <: AbstractSparseArrayImplementationStyle end
+abstract type AbstractDiagonalArrayImplementationStyle <:
+AbstractSparseArrayImplementationStyle end
 
 struct DiagonalArrayImplementationStyle <: AbstractDiagonalArrayImplementationStyle end
 const diag_style = DiagonalArrayImplementationStyle()
@@ -119,7 +120,7 @@ using MapBroadcast: Mapped
 function broadcasted_diagview(bc::Broadcasted)
     m = Mapped(bc)
     iszero(m.f(map(zero ∘ eltype, m.args)...)) || error(
-        "Broadcasting DiagonalArrays with function that doesn't preserve zeros isn't supported yet.",
+        "Broadcasting DiagonalArrays with function that doesn't preserve zeros isn't supported yet."
     )
     return broadcasted(m.f, map(diagview, m.args)...)
 end

src/diagonalarray/delta.jl

@@ -1,12 +1,15 @@
 using FillArrays: AbstractFillVector, Ones, OnesVector
 
-const ScaledDelta{T, N, Diag <: AbstractFillVector{T}, Unstored <: AbstractArray{T, N}} = DiagonalArray{
+const ScaledDelta{T, N, Diag <: AbstractFillVector{T}, Unstored <: AbstractArray{T, N}} =
+    DiagonalArray{
     T, N, Diag, Unstored,
 }
-const ScaledDeltaVector{T, Diag <: AbstractFillVector{T}, Unstored <: AbstractVector{T}} = DiagonalVector{
+const ScaledDeltaVector{T, Diag <: AbstractFillVector{T}, Unstored <: AbstractVector{T}} =
+    DiagonalVector{
     T, Diag, Unstored,
 }
-const ScaledDeltaMatrix{T, Diag <: AbstractFillVector{T}, Unstored <: AbstractMatrix{T}} = DiagonalMatrix{
+const ScaledDeltaMatrix{T, Diag <: AbstractFillVector{T}, Unstored <: AbstractMatrix{T}} =
+    DiagonalMatrix{
     T, Diag, Unstored,
 }
 
@@ -45,16 +48,24 @@ function Delta{T}(ax::Tuple{}) where {T}
 end
 
 function delta(
-        elt::Type, ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}}
+        elt::Type, ax::Tuple{
+            AbstractUnitRange{<:Integer},
+            Vararg{AbstractUnitRange{<:Integer}},
+        }
     )
     return Delta{elt}(ax)
 end
 function δ(
-        elt::Type, ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}}
+        elt::Type, ax::Tuple{
+            AbstractUnitRange{<:Integer},
+            Vararg{AbstractUnitRange{<:Integer}},
+        }
     )
     return delta(elt, ax)
 end
-function delta(ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}})
+function delta(
+        ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}}
+    )
     return delta(Float64, ax)
 end
 function δ(ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}})

src/diagonalarray/diagonalarray.jl

@@ -128,69 +128,69 @@ end
 # Constructor from diagonal entries accepting axes.
 function DiagonalArray{T, N}(
         diag::AbstractVector,
-        ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}},
+        ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}}
     ) where {T, N}
     N == length(ax) || throw(ArgumentError("Wrong number of axes"))
     return DiagonalArray(convert(AbstractVector{T}, diag), Unstored(Zeros{T}(ax)))
 end
 function DiagonalArray{T, N}(
         diag::AbstractVector,
         ax1::AbstractUnitRange{<:Integer},
-        axs::AbstractUnitRange{<:Integer}...,
+        axs::AbstractUnitRange{<:Integer}...
     ) where {T, N}
     return DiagonalArray{T, N}(diag, (ax1, axs...))
 end
 function DiagonalArray{T}(
         diag::AbstractVector,
-        ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}},
+        ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}}
     ) where {T}
     return DiagonalArray{T, length(ax)}(diag, ax)
 end
 function DiagonalArray{T}(
         diag::AbstractVector,
         ax1::AbstractUnitRange{<:Integer},
-        axs::AbstractUnitRange{<:Integer}...,
+        axs::AbstractUnitRange{<:Integer}...
     ) where {T}
     return DiagonalArray{T}(diag, (ax1, axs...))
 end
 function DiagonalArray(
         diag::AbstractVector{T},
-        ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}},
+        ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}}
     ) where {T}
     return DiagonalArray{T, length(ax)}(diag, ax)
 end
 function DiagonalArray(
         diag::AbstractVector,
         ax1::AbstractUnitRange{<:Integer},
-        axs::AbstractUnitRange{<:Integer}...,
+        axs::AbstractUnitRange{<:Integer}...
     )
     return DiagonalArray(diag, (ax1, axs...))
 end
 
 # undef constructors accepting axes.
 function DiagonalArray{T, N}(
         ::UndefInitializer,
-        ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}},
+        ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}}
     ) where {T, N}
     return DiagonalArray{T, N}(Vector{T}(undef, minimum(length, ax)), ax)
 end
 function DiagonalArray{T, N}(
         ::UndefInitializer,
         ax1::AbstractUnitRange{<:Integer},
-        axs::AbstractUnitRange{<:Integer}...,
+        axs::AbstractUnitRange{<:Integer}...
     ) where {T, N}
     return DiagonalArray{T, N}(undef, (ax1, axs...))
 end
 function DiagonalArray{T}(
         ::UndefInitializer,
-        ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}},
+        ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}}
     ) where {T}
     return DiagonalArray{T, length(ax)}(undef, ax)
 end
 function DiagonalArray{T}(
         ::UndefInitializer,
         ax1::AbstractUnitRange{<:Integer},
-        axs::AbstractUnitRange{<:Integer}...,
+        axs::AbstractUnitRange{<:Integer}...
     ) where {T}
     return DiagonalArray{T}(undef, (ax1, axs...))
 end
@@ -221,7 +221,7 @@ end
 
 function DiagonalArray{<:Any, N}(
         diag::AbstractVector{T},
-        ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}},
+        ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}}
     ) where {T, N}
     return DiagonalArray{T, N}(diag, ax)
 end

src/diagonalarray/diagonalmatrix.jl

@@ -1,4 +1,5 @@
-const DiagonalMatrix{T, Diag <: AbstractVector{T}, Unstored <: AbstractMatrix{T}} = DiagonalArray{
+const DiagonalMatrix{T, Diag <: AbstractVector{T}, Unstored <: AbstractMatrix{T}} =
+    DiagonalArray{
     T, 2, Diag, Unstored,
 }
 
@@ -11,7 +12,7 @@ function mul_diagviews(a1, a2)
     dual(axes(a1, 2)) == axes(a2, 1) || throw(
         DimensionMismatch(
             lazy"Incompatible dimensions for multiplication: $(axes(a1)) and $(axes(a2))"
-        ),
+        )
     )
     d1 = diagview(a1)
     d2 = diagview(a2)
@@ -25,12 +26,12 @@ function mul!_diagviews(a_dest, a1, a2)
     axes(a_dest, 1) == axes(a1, 1) || throw(
         DimensionMismatch(
             lazy"Incompatible dimensions for multiplication: $(axes(a_dest)) and $(axes(a1))"
-        ),
+        )
     )
     axes(a_dest, 2) == axes(a2, 2) || throw(
         DimensionMismatch(
             lazy"Incompatible dimensions for multiplication: $(axes(a_dest)) and $(axes(a2))"
-        ),
+        )
     )
     d_dest = diagview(a_dest)
     d1, d2 = mul_diagviews(a1, a2)

src/diagonalarray/diagonalvector.jl

@@ -1,4 +1,5 @@
-const DiagonalVector{T, Diag <: AbstractVector{T}, Unstored <: AbstractVector{T}} = DiagonalArray{
+const DiagonalVector{T, Diag <: AbstractVector{T}, Unstored <: AbstractVector{T}} =
+    DiagonalArray{
     T, 1, Diag, Unstored,
 }