WIP: Add new types QuStateVec and QuDensityMatrix.

src/QuBase.jl

@@ -48,7 +48,8 @@ module QuBase
     ######################
         include("bases/bases.jl")
         include("arrays/arrays.jl")
-
+        include("states/states.jl")
+
     export AbstractStructure, 
         AbstractQuantum,
         Orthogonal,

src/arrays/arraymath.jl

@@ -122,6 +122,9 @@ end
 
 normalize(qarr::AbstractQuArray) = normalize!(copy(qarr))
 
+Base.trace(qarr::AbstractQuMatrix) = trace(rawcoeffs(qarr))
+Base.trace(dm::DualMatrix) = trace(rawcoeffs(dm))'
+
 
 # matrix operations returning an array
 # sparse to dense
@@ -130,15 +133,20 @@ function Base.full(qarr::AbstractQuMatrix)
     QAT = similar_type(typeof(qarr))
     return QAT(fc, bases(qarr))
 end
-#Base.full(ct::CTranspose) = full(ct.qarr)'
 
 # exponential of dense matrix
 function Base.expm(qarr::AbstractQuMatrix)
     fc = expm(full(rawcoeffs(qarr)))
     QAT = similar_type(typeof(qarr))
     return QAT(fc, bases(qarr))
 end
-#Base.expm(ct::CTranspose) = expm(ct.qarr)'
+
+# square root of dense matrix
+function Base.sqrtm(qarr::AbstractQuMatrix)
+    fc = sqrtm(full(rawcoeffs(qarr)))
+    QAT = similar_type(typeof(qarr))
+    return QAT(fc, bases(qarr))
+end
 
 
 ##################

src/states/states.jl

@@ -0,0 +1,76 @@
+##############
+# QuStateVec #
+##############
+
+# pure state (aka state vector) type
+type QuStateVec{B,T,A} <: AbstractQuVector{B,T}
+    state::QuVector{B,T,A}
+
+    QuStateVec(state::QuVector{B,T,A}) = new(state)
+end
+
+QuStateVec{B,T}(coeffs::AbstractVector{T}, basis::B) = QuStateVec(QuArray(coeffs, basis))
+QuStateVec{B,T,A}(qa::QuVector{B,T,A}) = QuStateVec{B,T,A}(qa)
+
+# interface functions for AbstractQuArray
+coefftype{B,T,A}(::QuStateVec{B,T,A}) = A
+
+rawcoeffs(qa::QuStateVec) = rawcoeffs(qa.state)
+rawbases(qa::QuStateVec) = rawbases(qa.state)
+rawbases(qa::QuStateVec, i) = rawbases(qa.state, i)
+
+similar_type{Q<:QuStateVec}(::Type{Q}) = QuStateVec
+
+Base.copy(qs::QuStateVec) = QuStateVec(copy(qs.state))
+Base.promote_rule{B1,B2,T1,T2,A1,A2}(::Type{QuStateVec{B1,T1,A1}}, ::Type{QuVector{B2,T2,A2}}) = QuArray{promote_type(B1,B2),promote_type(T1,T2),1,promote_type(A1,A2)}
+
+
+# extract populations (occupation probabilities)
+populations( qs::QuStateVec ) = abs2( coeffs(qs) )
+
+# purity of the state vector
+purity( qs::QuStateVec ) = norm(qs)^2
+
+
+###################
+# QuDensityMatrix #
+###################
+
+# density matrix type
+type QuDensityMatrix{B,T,A} <: AbstractQuMatrix{B,T}
+    state::QuMatrix{B,T,A}
+
+    QuDensityMatrix(state::QuMatrix{B,T,A}) = new(state)
+end
+
+QuDensityMatrix{B,T,A}(qa::QuMatrix{B,T,A}) = QuDensityMatrix{B,T,A}(qa)
+QuDensityMatrix{B,T}(coeffs::AbstractMatrix{T}, bases::NTuple{2,B}) = QuDensityMatrix(QuArray(coeffs, bases))
+QuDensityMatrix{B,T}(coeffs::AbstractMatrix{T}, basis1::B, basis2::B) = QuDensityMatrix(coeffs, (basis1,basis2))
+
+# TO FIX
+#QuDensityMatrix(sv::QuStateVec) = QuDensityMatrix(sv*sv')
+
+# interface functions for AbstractQuArray
+coefftype{B,T,A}(::QuDensityMatrix{B,T,A}) = A
+
+rawcoeffs(qa::QuDensityMatrix) = rawcoeffs(qa.state)
+rawbases(qa::QuDensityMatrix) = rawbases(qa.state)
+rawbases(qa::QuDensityMatrix, i) = rawbases(qa.state, i)
+
+similar_type{Q<:QuDensityMatrix}(::Type{Q}) = QuDensityMatrix
+
+Base.copy(qs::QuDensityMatrix) = QuStateVec(copy(qs.state))
+Base.promote_rule{B1,B2,T1,T2,A1,A2}(::Type{QuDensityMatrix{B1,T1,A1}}, ::Type{QuMatrix{B2,T2,A2}}) = QuArray{promote_type(B1,B2),promote_type(T1,T2),1,promote_type(A1,A2)}
+
+# norm of density matrix
+Base.norm( qs::QuDensityMatrix ) = trace( qs.state )
+
+# extract populations (occupation probabilities)
+populations( qs::QuDensityMatrix ) = diag( coeffs(qs) )
+
+# purity of the state
+purity( qs::QuDensityMatrix ) = trace( coeffs(qs)*coeffs(qs) )
+
+
+export QuStateVec, QuDensityMatrix,
+    populations, purity