Request For Comment: Arithemtic between Operators and LazyOperators #86
There are no files selected for viewing
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -96,22 +96,48 @@ isequal(x::LazyTensor, y::LazyTensor) = samebases(x,y) && isequal(x.indices, y.i | |
| # Arithmetic operations | ||
| -(a::LazyTensor) = LazyTensor(a, -a.factor) | ||
|
|
||
|
There was a problem hiding this comment. This is the only place I am not sure about defaulting to laziness. It's quite a special case, but I encounter it quite a bit. I suppose the reason to do lazy summing here is mainly to be consistent with the laziness-preserving principle. I have some code that makes use of the existing behavior, but of course I can still do this kind of concrete summing manually if I want to, so I'm not arguing hard to keep it. What are your thoughts? There was a problem hiding this comment. My experience was that the previous implementation was very limiting. Especially since the custom operators I have been playing around with were not DataOperators but AbstractOperators, where the operation was defined via a function rather than a matrix. Therefore, these cannot be trivially added (except by using LazySum), and the above implementation fails. Also, length(a.indices) ==1 is required, and I could imagine situations where one would like to be able to add LazyTensors containing more than one operator. However, one could perhaps keep the original behavior by dispatching on LazyTensors containing only one DataOperator. That is adding a function like this (draft, I'm not entirely sure it works): const single_dataoperator{B1,B2} = LazyTensor{B1,B2,ComplexF64,Vector{Int64},Tuple{T}} where {B1,B2,T<:DataOperator}
function +(a::T1,b::T2) where {T1 <: single_dataoperator{B1,B2},T2 <: single_dataoperator{B1,B2}}
if length(a.indices) == 1 && a.indices == b.indices
op = a.operators[1] * a.factor + b.operators[1] * b.factor
return LazyTensor(a.basis_l, a.basis_r, a.indices, (op,))
end
throw(ArgumentError("Addition of LazyTensor operators is only defined in case both operators act nontrivially on the same, single tensor factor."))
endThere was a problem hiding this comment. @mabuni1998 I think it's worth trying to keep the original intact as you suggest. If we can handle it via dispatch, we won't lose anything. Or am I missing some case here? There was a problem hiding this comment. No I don't think we will lose anything. I have implemented to above as: There was a problem hiding this comment. Thanks for finding a way to keep the original behavior. This is not type-stable, but I can't think of an obvious way to make it otherwise, except by letting LazyTensor There was a problem hiding this comment. Probably won't be performance-critical no, as you are most likely creating the operators once at the beginning of the simulation and then not changing them as you do multiplications etc. |
||
| function +(a::LazyTensor{B1,B2},b::LazyTensor{B1,B2}) where {B1,B2} | ||
amilsted marked this conversation as resolved.
Show resolved
Hide resolved
|
||
| LazySum(a,b) | ||
| end | ||
| function -(a::LazyTensor{B1,B2},b::LazyTensor{B1,B2}) where {B1,B2} | ||
| LazySum((1,-1),(a,b)) | ||
| end | ||
| function +(a::LazyTensor{B1,B2},b::Operator{B1,B2}) where {B1,B2} | ||
| LazySum(a) + b | ||
| end | ||
| function +(a::Operator{B1,B2},b::LazyTensor{B1,B2}) where {B1,B2} | ||
| +(b,a) | ||
| end | ||
| function -(a::LazyTensor{B1,B2},b::Operator{B1,B2}) where {B1,B2} | ||
| LazySum(a) - b | ||
| end | ||
| function -(a::Operator{B1,B2},b::LazyTensor{B1,B2}) where {B1,B2} | ||
| a - LazySum(b) | ||
| end | ||
|
|
||
| function tensor(a::LazyTensor{B1,B1},b::Operator{B2,B2}) where {B1,B2} | ||
| if isequal(b,identityoperator(basis(b))) | ||
| btotal = basis(a) ⊗ basis(b) | ||
| LazyTensor(btotal,btotal,a.indices,(a.operators...,),a.factor) | ||
| elseif B2 <: CompositeBasis | ||
| throw(ArgumentError("tensor(a::LazyTensor{B1,B1},b::Operator{B2,B2}) is not implemented for B2 being CompositeBasis ")) | ||
| else | ||
| a ⊗ LazyTensor(b.basis_l,b.basis_r,[1],(b,),1) | ||
| end | ||
| end | ||
| function tensor(a::Operator{B1,B1},b::LazyTensor{B2,B2}) where {B1,B2} | ||
| if isequal(a,identityoperator(basis(a))) | ||
| btotal = basis(a) ⊗ basis(b) | ||
| LazyTensor(btotal,btotal,b.indices.+length(basis(a).shape) ,(b.operators...,),b.factor) | ||
| elseif B1 <: CompositeBasis | ||
| throw(ArgumentError("tensor(a::Operator{B1,B1},b::LazyTensor{B2,B2}) is not implemented for B1 being CompositeBasis ")) | ||
| else | ||
| LazyTensor(a.basis_l,a.basis_r,[1],(a,),1) ⊗ b | ||
| end | ||
| end | ||
|
|
||
|
|
||
|
|
||
| function *(a::LazyTensor{B1,B2}, b::LazyTensor{B2,B3}) where {B1,B2,B3} | ||
| indices = sort(union(a.indices, b.indices)) | ||
| # ops = Vector{AbstractOperator}(undef, length(indices)) | ||
|
|
||
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
this probably should be deleted before merging
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Oh yeah... Done that now ;)