quantumlib
Faster normal_ordered() suggestion
It is about the function normal_ordered_ladder_term().
I realized that we can actually break the layer of for j in range(i, 0, -1): .
Since if no action at the certain j th index, it implies everything in front of that is well-ordered and every loops afterward are redundant.
I tried in my code and it seems no difference in terms of result, but gain 25% improved performance.
Can anyone verify this?
update: Oh I saw the problem. I haven't account for the situation list 3^ 2^ 1 0 9^, which it is necessary to put 9^ in front of 3^. So simply just can't break the scanning until it scans the whole line.
update: No. I am 85% sure that I was right. Say it is in i_1 and looping through j. When all j for i_1 is finished, everything in front of i_1 should be well-order. Same thing applies to i_2, i_3, i_4, ... Anything in front of i_[n-1] is well ordered. If j th component do not need to swap places with (j-1)th in the first place, then there is no place for it to swap, so we can break the j loop.
Hi @eul94458 can you be a bit more specific here? maybe with a worked example? Certainly there are a lot of improvements we can apply to this area of the code and it would be great to see performance gains here.
Hi @eul94458 can you be a bit more specific here? maybe with a worked example? Certainly there are a lot of improvements we can apply to this area of the code and it would be great to see performance gains here.
Say there is a fermion operator (6^ 5^ 3 2^ 1 0)
First the program will look at compare (6^, 5^), then it see it is normal ordered, it proceed to next comparison.
Next is (3, 2^), it is not normal ordered, so indices are swaped. New operator will be (6^ 5^ 2^ 3 1 0).
Next it will compare (5^, 2^), and this is normal.
Then (6^ 5^), this is normal too.
And then I notice that we have already compared (6^ 5^) at the very first moment, so this time, the comparison is totally unnecessary and can be skipped.
It might look like this if you want the code.
# Swap operators if raising on right and lowering on left.
if right_operator[1] and not left_operator[1]:
# Handle case when operator type is the same.
elif right_operator[1] == left_operator[1]:
# If same two Fermionic operators are repeated,
# evaluate to zero.
if parity == -1 and right_operator[0] == left_operator[0]:
# Swap if same ladder type but lower index on left.
elif right_operator[0] > left_operator[0]:
################## NEW ################
# Break since everything in the front is well ordered
else:
break
#######################################