Make tests and add Val on missing cases

Author: albertomercurio

benchmarks/eigenvalues.jl

@@ -17,7 +17,7 @@ function benchmark_eigenvalues!(SUITE)
 
     SUITE["Eigenvalues"]["eigenstates"]["dense"] = @benchmarkable eigenstates($L)
     SUITE["Eigenvalues"]["eigenstates"]["sparse"] =
-        @benchmarkable eigenstates($L, sparse = true, sigma = 0.01, eigvals = 5)
+        @benchmarkable eigenstates($L, sparse = Val(true), sigma = 0.01, eigvals = 5)
 
     return nothing
 end

test/core-test/eigenvalues_and_operators.jl

@@ -1,19 +1,19 @@
 @testitem "Eigenvalues" begin
     σx = sigmax()
-    result = eigenstates(σx, sparse = false)
+    result = eigenstates(σx, sparse = Val(false))
     λd, ψd, Td = result
     resstring = sprint((t, s) -> show(t, "text/plain", s), result)
     valstring = sprint((t, s) -> show(t, "text/plain", s), result.values)
     vecsstring = sprint((t, s) -> show(t, "text/plain", s), result.vectors)
-    λs, ψs, Ts = eigenstates(σx, sparse = true, eigvals = 2)
-    λs1, ψs1, Ts1 = eigenstates(σx, sparse = true, eigvals = 1)
+    λs, ψs, Ts = eigenstates(σx, sparse = Val(true), eigvals = 2)
+    λs1, ψs1, Ts1 = eigenstates(σx, sparse = Val(true), eigvals = 1)
 
     @test all([ψ.type isa Ket for ψ in ψd])
     @test typeof(Td) <: AbstractMatrix
     @test typeof(Ts) <: AbstractMatrix
     @test typeof(Ts1) <: AbstractMatrix
-    @test all(abs.(eigenenergies(σx, sparse = false)) .≈ abs.(λd))
-    @test all(abs.(eigenenergies(σx, sparse = true, eigvals = 2)) .≈ abs.(λs))
+    @test all(abs.(eigenenergies(σx, sparse = Val(false))) .≈ abs.(λd))
+    @test all(abs.(eigenenergies(σx, sparse = Val(true), eigvals = 2)) .≈ abs.(λs))
     @test resstring ==
           "EigsolveResult:   type=$(Operator())   dims=$(result.dims)\nvalues:\n$(valstring)\nvectors:\n$vecsstring"
 
@@ -33,7 +33,7 @@
 
     vals_d, vecs_d, mat_d = eigenstates(H_d)
     vals_c, vecs_c, mat_c = eigenstates(H_c)
-    vals2, vecs2, mat2 = eigenstates(H_d, sparse = true, sigma = -0.9, eigvals = 10, krylovdim = 30, by = real)
+    vals2, vecs2, mat2 = eigenstates(H_d, sparse = Val(true), sigma = -0.9, eigvals = 10, krylovdim = 30, by = real)
 
     @test real.(vals_d[1:20]) ≈ real.(vals_c[1:20])
     @test real.(vals_d[1:10]) ≈ real.(vals2[1:10])
@@ -67,7 +67,7 @@
     @test vec2mat(vecs[:, 1]) * exp(-1im * angle(vecs[1, 1])) ≈ vec2mat(vecs3[:, 1]) atol=1e-5
 
     # eigen solve for QuantumObject
-    result = eigenstates(L, sparse = true, sigma = 0.01, eigvals = 10, krylovdim = 50)
+    result = eigenstates(L, sparse = Val(true), sigma = 0.01, eigvals = 10, krylovdim = 50)
     vals, vecs = result
     resstring = sprint((t, s) -> show(t, "text/plain", s), result)
     valstring = sprint((t, s) -> show(t, "text/plain", s), result.values)
@@ -105,7 +105,20 @@
         c_ops = [√((1 + n_th) * κ) * a, √κ * b, √(n_th * κ) * a_d]
         L = liouvillian(H, c_ops)
 
-        UnionType = Union{QuantumToolbox.EigsolveResult{Vector{ComplexF64}, Matrix{ComplexF64}, QuantumToolbox.Operator, QuantumToolbox.Dimensions{2, Tuple{QuantumToolbox.Space, QuantumToolbox.Space}}}, QuantumToolbox.EigsolveResult{Vector{Float64}, Matrix{ComplexF64}, QuantumToolbox.Operator, QuantumToolbox.Dimensions{2, Tuple{QuantumToolbox.Space, QuantumToolbox.Space}}}}
+        UnionType = Union{
+            QuantumToolbox.EigsolveResult{
+                Vector{ComplexF64},
+                Matrix{ComplexF64},
+                QuantumToolbox.Operator,
+                QuantumToolbox.Dimensions{2,Tuple{QuantumToolbox.Space,QuantumToolbox.Space}},
+            },
+            QuantumToolbox.EigsolveResult{
+                Vector{Float64},
+                Matrix{ComplexF64},
+                QuantumToolbox.Operator,
+                QuantumToolbox.Dimensions{2,Tuple{QuantumToolbox.Space,QuantumToolbox.Space}},
+            },
+        }
 
         @inferred UnionType eigenstates(H, sparse = Val(false))
         @inferred eigenstates(H, sparse = Val(true))

test/core-test/states_and_operators.jl

@@ -18,7 +18,7 @@
 
     @testset "fock state" begin
         # fock, basis, and fock_dm
-        @test fock_dm(4; dims = (2, 2), sparse = true) ≈ ket2dm(basis(4; dims = (2, 2)))
+        @test fock_dm(4; dims = (2, 2), sparse = Val(true)) ≈ ket2dm(basis(4; dims = (2, 2)))
         @test_throws DimensionMismatch fock(4; dims = 2)
         @test_throws ArgumentError fock(4, 4)
     end
@@ -37,7 +37,7 @@
 
     @testset "thermal state" begin
         ρTd = thermal_dm(5, 0.123)
-        ρTs = thermal_dm(5, 0.123; sparse = true)
+        ρTs = thermal_dm(5, 0.123; sparse = Val(true))
         @test isoper(ρTd)
         @test ρTd.dims == [5]
         @test tr(ρTd) ≈ 1.0
@@ -180,7 +180,7 @@
     end
 
     @testset "tunneling" begin
-        @test tunneling(10, 2) == tunneling(10, 2; sparse = true)
+        @test tunneling(10, 2) == tunneling(10, 2; sparse = Val(true))
         @test_throws ArgumentError tunneling(10, 0)
     end
 

test/ext-test/cpu/arbitrary_precision/arbitrary_precision.jl

@@ -43,8 +43,8 @@
         L = liouvillian(H, c_ops)
         L_big = liouvillian(H_big, c_ops_big)
 
-        vals, vecs = eigenstates(L; sparse = true, sigma = 0.01, eigvals = 7, krylovdim = 30)
-        vals_big, vecs_big = eigenstates(L_big; sparse = true, sigma = 0.01, eigvals = 7, krylovdim = 30)
+        vals, vecs = eigenstates(L; sparse = Val(true), sigma = 0.01, eigvals = 7, krylovdim = 30)
+        vals_big, vecs_big = eigenstates(L_big; sparse = Val(true), sigma = 0.01, eigvals = 7, krylovdim = 30)
 
         # Align eigenvalues
         idxs = [findmin(abs.(vals_big .- val))[2] for val in vals]

test/ext-test/gpu/cuda_ext.jl

@@ -274,16 +274,27 @@ end
 
     a = destroy(N)
     H = Δ * a' * a + U / 2 * a' * a' * a * a + F * (a + a')
+    H_gpu = cu(H)
 
     c_ops = [sqrt(κ) * a]
 
     L = liouvillian(H, c_ops)
     L_gpu = CuSparseMatrixCSR(L)
 
-    vals_cpu, vecs_cpu = eigenstates(L; sparse = true, sigma = 0.01, eigvals = 4, krylovdim = 30)
+    # Dense eigen solver for Hamiltonian
+    vals_H_cpu, vecs_H_cpu = eigenstates(H)
+    vals_H_gpu, vecs_H_gpu = eigenstates(H_gpu)
+
+    @test vals_H_cpu ≈ Array(vals_H_gpu) atol = 1e-8
+    @test all(zip(vecs_H_cpu, vecs_H_gpu)) do (v_cpu, v_gpu)
+        return isapprox(abs(dot(v_cpu.data, Array(v_gpu.data))), 1; atol = 1e-8)
+    end
+
+    # Sparse eigen solver for Liouvillian
+    vals_cpu, vecs_cpu = eigenstates(L; sparse = Val(true), sigma = 0.01, eigvals = 4, krylovdim = 30)
     vals_gpu, vecs_gpu = eigenstates(
         L_gpu;
-        sparse = true,
+        sparse = Val(true),
         sigma = 0.01,
         eigvals = 4,
         krylovdim = 30,