The tag name "0.3.3" is not of the appropriate SemVer form (vX.Y.Z).
cc: @Roger-luo

This package contains a lot workarounds which contains type piracy, need to check if they are in Base already or PR to upstream.

the 3-arg and 5-arg mul! is quite useful for ODE solvers, e.g the 5-arg mul! can be used in ODE solver directly and has no allocation comparing to apply! in YaoArrayRegister will require a copy of the state

This issue is used to trigger TagBot; feel free to unsubscribe.

If you haven't already, you should update your TagBot.yml to include issue comment triggers.
Please see this post on Discourse for instructions and more details.

If you'd like for me to do this for you, comment TagBot fix on this issue.
I'll open a PR within a few hours, please be patient!

• LuxurySparse.jl/src/linalg.jl

  Line 174 in cc2d19a

  function mul!(Y::SparseMatrixCSC, X::SparseMatrixCSC, A::Diagonal{T,Vector{T}}) where {T}

  this is available in: https://github.com/JuliaLang/julia/blob/master/stdlib/SparseArrays/src/linalg.jl#L1464

# Intrinsics/Math.jl: 146
linop2dense(applyfunc!::Function, num_bit::Int) = applyfunc!(Matrix{ComplexF64}(I, 1<<num_bit, 1<<num_bit))

The result is incorrect when you use IMatrix, however IMatrix should act exactly like a dense identity, except it does not allocate memory.

need to wait for JuliaCI/PkgBenchmark.jl#68

I think now Julia broadcast uses a StructuredMatrix style to promote it to SparseMatrixCSC, no need to overload it anymore

The following example lightly adapted from the README

using SparseArrays
using LuxurySparse

pm = pmrand(7)

Spm = pm |> SparseMatrixCSC

spm = Spm |> staticize

@show spm

fails with a MethodError: no method matching _checkbuffers(::SSparseMatrixCSC{Float64, Int64, 7, 8}). The _checkbuffers method is called from Base.array_summary .

The REQUIRE file could not be found.
cc: @Roger-luo

Currently, things like sqrt(im * X) etc. is actually unitary, it can be constructed in this form

1/sqrt(2) * [1 -i;-i 1]

This will actually make some results incorrect without caution (e.g testing Clifford group), but it reduces readability if we directly normalize them instead of printing the definition above. Thus defining a Unitary would help, it will store the original matrix and its normalization factor:

struct ScaledMatrix{T, MT <: AbstractMatrix}
    factor::T
    parent::MT
end

currently not working on 1.5

Right now, I'm working on in-place, CPU versions of kronsum(A,B) = kron(A, oneunit(B)) + kron(oneunit(A), B)

So far, this works for dense arrays:

function kronsum!(C::AbstractMatrix, A::AbstractMatrix, B::AbstractMatrix)
    Base.require_one_based_indexing(A, B)
    (mA, nA) = size(A); (mB, nB) = size(B); (mC, nC) = size(C);
    @boundscheck (mC, nC) == (mA * mB, nA * nB) ||
        throw(DimensionMismatch("expect C to be a $(mA * mB)x$(nA * nB) matrix, got size $(mC)x$(nC)"))

    C .= 0
    m = 1
    @inbounds for j = 1:nA
        for l = 1:mB
            for k = 1:mA
                C[m] = A[k,j]
                m += nB
            end
            m += 1
        end
        m -= nB
    end

    m = 1
    @inbounds for j = 1:nA
        for k = 1:nB
            for l = 1:mB
                C[m] += B[l,k]
                m += 1
            end
            m += (nA - 1) * mB
        end
        m += mB
    end

    return C
end

A = rand(3,3); B = rand(2,2); C = zeros(6,6);
C == kron(A, oneunit(B)) + kron(oneunit(A), B) # true

I'm having trouble doing something similar with SparseMatrixCSC, since parts of A and B only overlap on the diagonal of C.

Using Diagonal Format (from DIA.jl) could work, but I think converting to CSC would take too much time (especially if either A or B are sparse) and there's the risk of storing too many zeroes for the diagonal storage Vectors.

Currently, I'm inspired by the sparse kron! in JuliaLang/julia#31069. It works for either kron(A,oneunit(B)) or kron(oneunit(A), B), but not the sum.

• Could I use two loops like I did for the dense arrays? (One nested loop for A, the other for B)
• Can I somehow efficiently check if an index points to a diagonal term of C where C isa SparseMatrixCSC?

JuliaLang/julia#34209 causes nzval to be empty on zero meaning that rand! does nothing and the test fails:

randn: Test Failed at /home/pkgeval/.julia/packages/LuxurySparse/uj6P5/test/linalg.jl:89
  Expression: !(zm ≈ zeros(T, 5, 5))

@JuliaRegistrator register()

LLVM could have bad performance here, for nested loop.

this could cause failure on SIMD

Use view or use view when this is larger than a threshold.

• some place like this only need one @inbounds, not a big problem though
• benchmark

• Use view or use view when this is larger than a threshold.
• benchmark

• LLVM could have bad performance here, for nested loop.
• benchmark

• this could cause failure on SIMD
• benchmark