fix: cleaner dispatching onto StaticArrays

docs/src/tutorials.md

@@ -60,7 +60,7 @@ can specify an array type in its first (and second) arguments. Let's see an exam
 ```jldoctest
 julia> using StaticArrays
 
-julia> state = coherentstate(SVector{2}, SMatrix{2,2}, QuadPairBasis(1), 1.0-im)
+julia> state = coherentstate(SVector, SMatrix, QuadPairBasis(1), 1.0-im)
 GaussianState for 1 mode.
   symplectic basis: QuadPairBasis
 mean: 2-element SVector{2, Float64} with indices SOneTo(2):

ext/StaticArraysExt/StaticArraysExt.jl

@@ -3,10 +3,13 @@ module StaticArraysExt
 using StaticArrays: SVector, SMatrix, SArray
 
 using Gabs
-import Gabs: ptrace, tensor, ⊗, _promote_output_matrix, _promote_output_vector, 
-            _generaldyne_map
+using Gabs: SymplecticBasis, QuadPairBasis
+
+import Gabs: ptrace, tensor, ⊗, _promote_output_matrix, _promote_output_vector,
+            _generaldyne_map, infer_mean_type, infer_covar_type, infer_displacement_type,
+            infer_symplectic_type, infer_transform_type
 
 include("utils.jl")
 include("measurements.jl")
 
-end
+end

ext/StaticArraysExt/utils.jl

@@ -14,4 +14,29 @@ Base.@propagate_inbounds function _promote_output_matrix(::Type{<:SMatrix}, mat_
 end
 Base.@propagate_inbounds function _promote_output_matrix(::Type{<:SMatrix}, mat_out, out_dim::Tuple)
     return SMatrix{out_dim[1],out_dim[2]}(mat_out)
-end
+end
+
+function infer_mean_type(::Type{SVector}, basis::Gabs.SymplecticBasis{N}) where {N}
+    nmodes = basis.nmodes
+    return SVector{2*nmodes, Float64}
+end
+
+function infer_covar_type(::Type{SMatrix}, basis::Gabs.SymplecticBasis{N}) where {N}
+    nmodes = basis.nmodes
+    return SMatrix{2*nmodes, 2*nmodes, Float64, 4*nmodes*nmodes}
+end
+
+function infer_displacement_type(::Type{SVector}, basis::Gabs.QuadPairBasis{N}) where {N}
+    nmodes = basis.nmodes
+    return SVector{2*nmodes, Float64}
+end
+
+function infer_symplectic_type(::Type{SMatrix}, basis::Gabs.QuadPairBasis{N}) where {N}
+    nmodes = basis.nmodes
+    return SMatrix{2*nmodes, 2*nmodes, Float64, 4*nmodes*nmodes}
+end
+
+function infer_transform_type(::Type{SMatrix}, basis::Gabs.SymplecticBasis{N}) where {N}
+    nmodes = basis.nmodes
+    return SMatrix{2*nmodes, 2*nmodes, Float64, 4*nmodes*nmodes}
+end

src/channels.jl

@@ -2,9 +2,21 @@
 # Predefined Gaussian channels
 ##
 
+function infer_transform_type end
+
+function infer_transform_type(::Type{Array}, basis::Gabs.SymplecticBasis{N}) where {N}
+    return Array{Float64, 2}
+end
+
+function infer_transform_type(::Type{Array{T}}, basis::Gabs.SymplecticBasis{N}) where {T, N}
+    return Array{T, 2}
+end
+
 function displace(::Type{Td}, ::Type{Tt}, basis::SymplecticBasis{N}, alpha::A, noise::M) where {Td,Tt,N<:Int,A,M}
+    disp_type = infer_displacement_type(Td, basis)
+    transform_type = infer_transform_type(Tt, basis)
     disp, transform = _displace(basis, alpha)
-    return GaussianChannel(basis, Td(disp), Tt(transform), Tt(noise))
+    return GaussianChannel(basis, disp_type(disp), transform_type(transform), transform_type(noise))
 end
 displace(::Type{T}, basis::SymplecticBasis{N}, alpha::A, noise::M) where {T,N<:Int,A,M} = displace(T, T, basis, alpha, noise)
 function displace(basis::SymplecticBasis{N}, alpha::A, noise::M) where {N<:Int,A,M}
@@ -13,8 +25,10 @@
 end
 
 function squeeze(::Type{Td}, ::Type{Tt}, basis::SymplecticBasis{N}, r::R, theta::R, noise::M) where {Td,Tt,N<:Int,R,M}
+    disp_type = infer_displacement_type(Td, basis)
+    transform_type = infer_transform_type(Tt, basis)
     disp, transform = _squeeze(basis, r, theta)
-    return GaussianChannel(basis, Td(disp), Tt(transform), Tt(noise))
+    return GaussianChannel(basis, disp_type(disp), transform_type(transform), transform_type(noise))
 end
 squeeze(::Type{T}, basis::SymplecticBasis{N}, r::R, theta::R, noise::M) where {T,N<:Int,R,M} = squeeze(T, T, basis, r, theta, noise)
 function squeeze(basis::SymplecticBasis{N}, r::R, theta::R, noise::M) where {N<:Int,R,M}
@@ -23,8 +37,10 @@
 end
 
 function twosqueeze(::Type{Td}, ::Type{Tt}, basis::SymplecticBasis{N}, r::R, theta::R, noise::M) where {Td,Tt,N<:Int,R,M}
+    disp_type = infer_displacement_type(Td, basis)
+    transform_type = infer_transform_type(Tt, basis)
     disp, transform = _twosqueeze(basis, r, theta)
-    return GaussianChannel(basis, Td(disp), Tt(transform), Tt(noise))
+    return GaussianChannel(basis, disp_type(disp), transform_type(transform), transform_type(noise))
 end
 twosqueeze(::Type{T}, basis::SymplecticBasis{N}, r::R, theta::R, noise::M) where {T,N<:Int,R,M} = twosqueeze(T, T, basis, r, theta, noise)
 function twosqueeze(basis::SymplecticBasis{N}, r::R, theta::R, noise::M) where {N<:Int,R,M}
@@ -33,8 +49,10 @@
 end
 
 function phaseshift(::Type{Td}, ::Type{Tt}, basis::SymplecticBasis{N}, theta::R, noise::M) where {Td,Tt,N<:Int,R,M}
+    disp_type = infer_displacement_type(Td, basis)
+    transform_type = infer_transform_type(Tt, basis)
     disp, transform = _phaseshift(basis, theta)
-    return GaussianChannel(basis, Td(disp), Tt(transform), Tt(noise))
+    return GaussianChannel(basis, disp_type(disp), transform_type(transform), transform_type(noise))
 end
 phaseshift(::Type{T}, basis::SymplecticBasis{N}, theta::R, noise::M) where {T,N<:Int,R,M} = phaseshift(T, T, basis, theta, noise)
 function phaseshift(basis::SymplecticBasis{N}, theta::R, noise::M) where {N<:Int,R,M}
@@ -43,8 +61,10 @@
 end
 
 function beamsplitter(::Type{Td}, ::Type{Tt}, basis::SymplecticBasis{N}, transmit::R, noise::M) where {Td,Tt,N<:Int,R,M}
+    disp_type = infer_displacement_type(Td, basis)
+    transform_type = infer_transform_type(Tt, basis)
     disp, transform = _beamsplitter(basis, transmit)
-    return GaussianChannel(basis, Td(disp), Tt(transform), Tt(noise))
+    return GaussianChannel(basis, disp_type(disp), transform_type(transform), transform_type(noise))
 end
 beamsplitter(::Type{T}, basis::SymplecticBasis{N}, transmit::R, noise::M) where {T,N<:Int,R,M} = beamsplitter(T, T, basis, transmit, noise)
 function beamsplitter(basis::SymplecticBasis{N}, transmit::R, noise::M) where {N<:Int,R,M}
@@ -84,8 +104,10 @@
 ```
 """
 function attenuator(::Type{Td}, ::Type{Tt}, basis::SymplecticBasis{N}, theta::R, n::M; ħ = 2) where {Td,Tt,N<:Int,R,M}
+    disp_type = infer_displacement_type(Td, basis)
+    transform_type = infer_transform_type(Tt, basis)
     disp, transform, noise = _attenuator(basis, theta, n)
-    return GaussianChannel(basis, Td(disp), Tt(transform), Tt(noise); ħ = ħ)
+    return GaussianChannel(basis, disp_type(disp), transform_type(transform), transform_type(noise); ħ = ħ)
 end
 attenuator(::Type{T}, basis::SymplecticBasis{N}, theta::R, n::M; ħ = 2) where {T,N<:Int,R,M} = attenuator(T, T, basis, theta, n; ħ = ħ)
 function attenuator(basis::SymplecticBasis{N}, theta::R, n::M; ħ = 2) where {N<:Int,R,M}
@@ -168,8 +190,10 @@
 ```
 """
 function amplifier(::Type{Td}, ::Type{Tt}, basis::SymplecticBasis{N}, r::R, n::M; ħ = 2) where {Td,Tt,N<:Int,R,M}
+    disp_type = infer_displacement_type(Td, basis)
+    transform_type = infer_transform_type(Tt, basis)
     disp, transform, noise = _amplifier(basis, r, n)
-    return GaussianChannel(basis, Td(disp), Tt(transform), Tt(noise); ħ = ħ)
+    return GaussianChannel(basis, disp_type(disp), transform_type(transform), transform_type(noise); ħ = ħ)
 end
 amplifier(::Type{T}, basis::SymplecticBasis{N}, r::R, n::M; ħ = 2) where {T,N<:Int,R,M} = amplifier(T, T, basis, r, n; ħ = ħ)
 function amplifier(basis::SymplecticBasis{N}, r::R, n::M; ħ = 2) where {N<:Int,R,M}

src/states.jl

@@ -2,6 +2,26 @@
 # Predefined Gaussian states
 ##
 
+function infer_mean_type end
+
+function infer_mean_type(::Type{Array}, basis::Gabs.SymplecticBasis{N}) where {N}
+    return Array
+end
+
+function infer_mean_type(::Type{Array{T}}, basis::Gabs.SymplecticBasis{N}) where {T, N}
+    return Array{T, 1}
+end
+
+function infer_covar_type end
+
+function infer_covar_type(::Type{Array}, basis::Gabs.SymplecticBasis{N}) where {N}
+    return Array
+end
+
+function infer_covar_type(::Type{Array{T}}, basis::Gabs.SymplecticBasis{N}) where {T, N}
+    return Array{T, 2}
+end
+
 """
     vacuumstate([Tm=Vector{Float64}, Tc=Matrix{Float64}], basis::SymplecticBasis)
 
@@ -27,8 +47,10 @@
 ```
 """
 function vacuumstate(::Type{Tm}, ::Type{Tc}, basis::SymplecticBasis{N}; ħ = 2) where {Tm,Tc,N<:Int}
-    mean, covar = _vacuumstate(basis; ħ = ħ)
-    return GaussianState(basis, Tm(mean), Tc(covar); ħ = ħ)
+    mean_type = infer_mean_type(Tm, basis)
+    covar_type = infer_covar_type(Tc, basis)
+    mean, covar = _vacuumstate(basis)
+    return GaussianState(basis,  mean_type(mean), covar_type(covar); ħ = ħ)
 end
 vacuumstate(::Type{T}, basis::SymplecticBasis{N}; ħ = 2) where {T,N<:Int} = vacuumstate(T, T, basis; ħ = ħ)
 function vacuumstate(basis::SymplecticBasis{N}; ħ = 2) where {N<:Int}
@@ -69,8 +91,10 @@
 ```
 """
 function thermalstate(::Type{Tm}, ::Type{Tc}, basis::SymplecticBasis{N}, photons::P; ħ = 2) where {Tm,Tc,N<:Int,P}
+    mean_type = infer_mean_type(Tm, basis)
+    covar_type = infer_covar_type(Tc, basis)
     mean, covar = _thermalstate(basis, photons; ħ = ħ)
-    return GaussianState(basis, Tm(mean), Tc(covar); ħ = ħ)
+    return GaussianState(basis, mean_type(mean), covar_type(covar); ħ = ħ)
 end
 thermalstate(::Type{T}, basis::SymplecticBasis{N}, photons::P; ħ = 2) where {T,N<:Int,P} = thermalstate(T, T, basis, photons; ħ = ħ)
 function thermalstate(basis::SymplecticBasis{N}, photons::P; ħ = 2) where {N<:Int,P}
@@ -137,8 +161,10 @@
 ```
 """
 function coherentstate(::Type{Tm}, ::Type{Tc}, basis::SymplecticBasis{N}, alpha::A; ħ = 2) where {Tm,Tc,N<:Int,A}
-    mean, covar = _coherentstate(basis, alpha; ħ = ħ)
-    return GaussianState(basis, Tm(mean), Tc(covar); ħ = ħ)
+    mean_type = infer_mean_type(Tm, basis)
+    covar_type = infer_covar_type(Tc, basis)
+    mean, covar = _coherentstate(basis, alpha)
+    return GaussianState(basis,  mean_type(mean), covar_type(covar); ħ = ħ)
 end
 coherentstate(::Type{T}, basis::SymplecticBasis{N}, alpha::A; ħ = 2) where {T,N<:Int,A} = coherentstate(T, T, basis, alpha; ħ = ħ)
 function coherentstate(basis::SymplecticBasis{N}, alpha::A; ħ = 2) where {N<:Int,A}
@@ -203,8 +229,10 @@
 ```
 """
 function squeezedstate(::Type{Tm}, ::Type{Tc}, basis::SymplecticBasis{N}, r::R, theta::R; ħ = 2) where {Tm,Tc,N<:Int,R}
-    mean, covar = _squeezedstate(basis, r, theta; ħ = ħ)
-    return GaussianState(basis, Tm(mean), Tc(covar); ħ = ħ)
+    mean_type = infer_mean_type(Tm, basis)
+    covar_type = infer_covar_type(Tc, basis)
+    mean, covar = _squeezedstate(basis, r, theta)
+    return GaussianState(basis,  mean_type(mean), covar_type(covar); ħ = ħ)
 end
 squeezedstate(::Type{T}, basis::SymplecticBasis{N}, r::R, theta::R; ħ = 2) where {T,N<:Int,R} = squeezedstate(T, T, basis, r, theta; ħ = ħ)
 function squeezedstate(basis::SymplecticBasis{N}, r::R, theta::R; ħ = 2) where {N<:Int,R}
@@ -303,8 +331,10 @@
 ```
 """
 function eprstate(::Type{Tm}, ::Type{Tc}, basis::SymplecticBasis{N}, r::R, theta::R; ħ = 2) where {Tm,Tc,N<:Int,R}
-    mean, covar = _eprstate(basis, r, theta; ħ = ħ)
-    return GaussianState(basis, Tm(mean), Tc(covar); ħ = ħ)
+    mean_type = infer_mean_type(Tm, basis)
+    covar_type = infer_covar_type(Tc, basis)
+    mean, covar = _eprstate(basis, r, theta)
+    return GaussianState(basis,  mean_type(mean), covar_type(covar); ħ = ħ)
 end
 eprstate(::Type{T}, basis::SymplecticBasis{N}, r::R, theta::R; ħ = 2) where {T,N<:Int,R} = eprstate(T, T, basis, r, theta; ħ = ħ)
 function eprstate(basis::SymplecticBasis{N}, r::R, theta::R; ħ = 2) where {N<:Int,R}

src/unitaries.jl

@@ -2,6 +2,30 @@
 # Predefined Gaussian unitaries
 ##
 
+function infer_displacement_type end
+
+function infer_symplectic_type end
+
+function infer_displacement_type(::Type{Array{T}}, basis::Gabs.QuadPairBasis{N}) where {T, N}
+    nmodes = basis.nmodes
+    return Array{T, 1}
+end
+
+function infer_displacement_type(::Type{Array}, basis::Gabs.QuadPairBasis{N}) where {N}
+    nmodes = basis.nmodes
+    return Array{Float64, 1}
+end
+
+function infer_symplectic_type(::Type{Array{T}}, basis::Gabs.QuadPairBasis{N}) where {T, N}
+    nmodes = basis.nmodes
+    return Array{T, 2}
+end
+
+function infer_symplectic_type(::Type{Array}, basis::Gabs.QuadPairBasis{N}) where {N}
+    nmodes = basis.nmodes
+    return Array{Float64, 2}
+end
+
 """
     displace([Tm=Vector{Float64}, Ts=Matrix{Float64}], basis::SymplecticBasis, alpha<:Number)
     displace([Tm=Vector{Float64}, Ts=Matrix{Float64}], basis::SymplecticBasis, alpha<:Number, noise::Ts)
@@ -32,8 +56,10 @@ symplectic: 2×2 Matrix{Float64}:
 ```
 """
 function displace(::Type{Td}, ::Type{Ts}, basis::SymplecticBasis{N}, alpha::A; ħ = 2) where {Td,Ts,N<:Int,A}
-    disp, symplectic = _displace(basis, alpha; ħ = ħ)
-    return GaussianUnitary(basis, Td(disp), Ts(symplectic); ħ = ħ)
+    disp_type = infer_displacement_type(Td, basis)
+    symplectic_type = infer_symplectic_type(Ts, basis)
+    disp, symplectic = _displace(basis, alpha)
+    return GaussianUnitary(basis, disp_type(disp), symplectic_type(symplectic); ħ = ħ)
 end
 displace(::Type{T}, basis::SymplecticBasis{N}, alpha::A; ħ = 2) where {T,N<:Int,A} = displace(T, T, basis, alpha; ħ = ħ)
 function displace(basis::SymplecticBasis{N}, alpha::A; ħ = 2) where {N<:Int,A}
@@ -103,8 +129,10 @@ symplectic: 2×2 Matrix{Float64}:
 ```
 """
 function squeeze(::Type{Td}, ::Type{Ts}, basis::SymplecticBasis{N}, r::R, theta::R; ħ = 2) where {Td,Ts,N<:Int,R}
+    disp_type = infer_displacement_type(Td, basis)
+    symplectic_type = infer_symplectic_type(Ts, basis)
     disp, symplectic = _squeeze(basis, r, theta)
-    return GaussianUnitary(basis, Td(disp), Ts(symplectic); ħ = ħ)
+    return GaussianUnitary(basis, disp_type(disp), symplectic_type(symplectic); ħ = ħ)
 end
 squeeze(::Type{T}, basis::SymplecticBasis{N}, r::R, theta::R; ħ = 2) where {T,N<:Int,R} = squeeze(T, T, basis, r, theta; ħ = ħ)
 function squeeze(basis::SymplecticBasis{N}, r::R, theta::R; ħ = 2) where {N<:Int, R}
@@ -208,8 +236,10 @@ symplectic: 4×4 Matrix{Float64}:
 ```
 """
 function twosqueeze(::Type{Td}, ::Type{Ts}, basis::SymplecticBasis{N}, r::R, theta::R; ħ = 2) where {Td,Ts,N<:Int,R}
+    disp_type = infer_displacement_type(Td, basis)
+    symplectic_type = infer_symplectic_type(Ts, basis)
     disp, symplectic = _twosqueeze(basis, r, theta)
-    return GaussianUnitary(basis, Td(disp), Ts(symplectic); ħ = ħ)
+    return GaussianUnitary(basis, disp_type(disp), symplectic_type(symplectic); ħ = ħ)
 end
 twosqueeze(::Type{T}, basis::SymplecticBasis{N}, r::R, theta::R; ħ = 2) where {T,N<:Int,R} = twosqueeze(T, T, basis, r, theta; ħ = ħ)
 function twosqueeze(basis::SymplecticBasis{N}, r::R, theta::R; ħ = 2) where {N<:Int,R}
@@ -353,8 +383,10 @@ symplectic: 2×2 Matrix{Float64}:
 ```
 """
 function phaseshift(::Type{Td}, ::Type{Ts}, basis::SymplecticBasis{N}, theta::R; ħ = 2) where {Td,Ts,N<:Int,R}
+    disp_type = infer_displacement_type(Td, basis)
+    symplectic_type = infer_symplectic_type(Ts, basis)
     disp, symplectic = _phaseshift(basis, theta)
-    return GaussianUnitary(basis, Td(disp), Ts(symplectic); ħ = ħ)
+    return GaussianUnitary(basis, disp_type(disp), symplectic_type(symplectic); ħ = ħ)
 end
 phaseshift(::Type{T}, basis::SymplecticBasis{N}, theta::R; ħ = 2) where {T,N<:Int,R} = phaseshift(T, T, basis, theta; ħ = ħ)
 function phaseshift(basis::SymplecticBasis{N}, theta::R; ħ = 2) where {N<:Int,R}
@@ -453,8 +485,10 @@ symplectic: 4×4 Matrix{Float64}:
 ```
 """
 function beamsplitter(::Type{Td}, ::Type{Ts}, basis::SymplecticBasis{N}, transmit::R; ħ = 2) where {Td,Ts,N<:Int,R}
+    disp_type = infer_displacement_type(Td, basis)
+    symplectic_type = infer_symplectic_type(Ts, basis)
     disp, symplectic = _beamsplitter(basis, transmit)
-    return GaussianUnitary(basis, Td(disp), Ts(symplectic); ħ = ħ)
+    return GaussianUnitary(basis, disp_type(disp), symplectic_type(symplectic); ħ = ħ)
 end
 beamsplitter(::Type{T}, basis::SymplecticBasis{N}, transmit::R; ħ = 2) where {T,N<:Int,R} = beamsplitter(T, T, basis, transmit; ħ = ħ)
 function beamsplitter(basis::SymplecticBasis{N}, transmit::R; ħ = 2) where {N<:Int,R}