/
qn.jl
339 lines (292 loc) · 7.23 KB
/
qn.jl
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
using ..ITensors: ITensors, name, val
using NDTensors: NDTensors
using ..SmallStrings: SmallString
using StaticArrays: MVector, SVector
const maxQNs = 4
const QNStorage = SVector{maxQNs,QNVal}
const MQNStorage = MVector{maxQNs,QNVal}
"""
A QN object stores a collection of up to four
named values such as ("Sz",1) or ("N",0).
These values can include a third integer "m"
which makes them obey addition modulo m, for
example ("P",1,2) for a value obeying addition mod 2.
(The default is regular integer addition).
Adding or subtracting pairs of QN objects performs
addition and subtraction element-wise on each of
the named values. If a name is missing from the
collection, its value is treated as zero.
"""
struct QN
data::QNStorage
function QN()
s = QNStorage(ntuple(_ -> ZeroVal, Val(maxQNs)))
return new(s)
end
QN(s::QNStorage) = new(s)
end
QN(mqn::MQNStorage) = QN(QNStorage(mqn))
QN(mqn::NTuple{N,QNVal}) where {N} = QN(QNStorage(mqn))
function Base.hash(obj::QN, h::UInt)
out = h
for qv in obj.data
if val(qv) != 0
out = hash(qv, out)
end
end
return out
end
"""
QN(qvs...)
Construct a QN from a set of up to four
named value tuples.
Examples
```julia
q = QN(("Sz",1))
q = QN(("N",1),("Sz",-1))
q = QN(("P",0,2),("Sz",0)).
```
"""
function QN(qvs...)
m = MQNStorage(ntuple(_ -> ZeroVal, Val(maxQNs)))
for (n, qv) in enumerate(qvs)
m[n] = QNVal(qv...)
end
Nvals = length(qvs)
sort!(@view m[1:Nvals]; by=name, alg=InsertionSort)
for n in 1:(length(qvs) - 1)
if name(m[n]) == name(m[n + 1])
error("Duplicate name \"$(name(m[n]))\" in QN")
end
end
return QN(QNStorage(m))
end
"""
QN(name,val::Int,modulus::Int=1)
Construct a QN with a single named value
by providing the name, value, and optional
modulus.
"""
QN(name, val::Int, modulus::Int=1) = QN((name, val, modulus))
"""
QN(val::Int,modulus::Int=1)
Construct a QN with a single unnamed value
(equivalent to the name being the empty string)
with optional modulus.
"""
QN(val::Int, modulus::Int=1) = QN(("", val, modulus))
data(qn::QN) = qn.data
Base.getindex(q::QN, n::Int) = getindex(data(q), n)
Base.length(qn::QN) = length(data(qn))
Base.lastindex(qn::QN) = length(qn)
isactive(qn::QN) = isactive(qn[1])
function nactive(q::QN)
for n in 1:maxQNs
!isactive(q[n]) && (return n - 1)
end
return maxQNs
end
function Base.iterate(qn::QN, state::Int=1)
(state > length(qn)) && return nothing
return (qn[state], state + 1)
end
Base.keys(qn::QN) = keys(data(qn))
"""
val(q::QN,name)
Get the value within the QN q
corresponding to the string `name`
"""
function ITensors.val(q::QN, name_)
sname = SmallString(name_)
for n in 1:maxQNs
name(q[n]) == sname && return val(q[n])
end
return 0
end
"""
modulus(q::QN,name)
Get the modulus within the QN q
corresponding to the string `name`
"""
function modulus(q::QN, name_)
sname = SmallString(name_)
for n in 1:maxQNs
name(q[n]) == sname && return modulus(q[n])
end
return 0
end
"""
zero(q::QN)
Returns a QN object containing
the same names as q, but with
all values set to zero.
"""
function Base.zero(qn::QN)
mqn = MQNStorage(undef)
for i in 1:length(mqn)
mqn[i] = zero(qn[i])
end
return QN(mqn)
end
function Base.:(*)(dir::Arrow, qn::QN)
mqn = MQNStorage(undef)
for i in 1:length(mqn)
mqn[i] = dir * qn[i]
end
return QN(mqn)
end
Base.:(*)(qn::QN, dir::Arrow) = (dir * qn)
function Base.:(-)(qn::QN)
mqn = MQNStorage(undef)
for i in 1:length(mqn)
mqn[i] = -qn[i]
end
return QN(mqn)
end
function Base.:(+)(a::QN, b::QN)
!isactive(b[1]) && return a
ma = MQNStorage(data(a))
@inbounds for nb in 1:maxQNs
!isactive(b[nb]) && break
bname = name(b[nb])
for na in 1:maxQNs
aname = name(a[na])
if !isactive(ma[na])
ma[na] = b[nb]
break
elseif name(ma[na]) == bname
ma[na] = ma[na] + b[nb]
break
elseif (bname < aname) && (na == 1 || bname > name(ma[na - 1]))
for j in maxQNs:-1:(na + 1)
ma[j] = ma[j - 1]
end
ma[na] = b[nb]
break
end
end
end
return QN(QNStorage(ma))
end
Base.:(-)(a::QN, b::QN) = (a + (-b))
function hasname(qn::QN, qv_find::QNVal)
for qv in qn
name(qv) == name(qv_find) && return true
end
return false
end
# Does not perform checks on if QN is already full, drops
# the last QNVal
# Rename insert?
function NDTensors.insertafter(qn::QN, qv::QNVal, pos::Int)
return QN(NDTensors.insertafter(Tuple(qn), qv, pos)[1:length(qn)])
end
function addqnval(qn::QN, qv_add::QNVal)
isactive(qn[end]) &&
error("Cannot add QNVal, QN already contains maximum number of QNVals")
for (pos, qv) in enumerate(qn)
if qv_add < qv || !isactive(qv)
return NDTensors.insertafter(qn, qv_add, pos - 1)
end
end
end
# Fills in the qns of qn1 that qn2 has but
# qn1 doesn't
function fillqns_from(qn1::QN, qn2::QN)
# If qn1 has no non-trivial qns, fill
# with qn2
!isactive(qn1) && return zero(qn2)
!isactive(qn2) && return qn1
for qv2 in qn2
if !hasname(qn1, qv2)
qn1 = addqnval(qn1, zero(qv2))
end
end
return qn1
end
# Make sure qn1 and qn2 have all of the same qns
function fillqns(qn1::QN, qn2::QN)
qn1_filled = fillqns_from(qn1, qn2)
qn2_filled = fillqns_from(qn2, qn1)
return qn1_filled, qn2_filled
end
function isequal_assume_filled(qn1::QN, qn2::QN)
for (qv1, qv2) in zip(qn1, qn2)
modulus(qv1) != modulus(qv2) && error("QNVals must have same modulus to compare")
qv1 != qv2 && return false
end
return true
end
function Base.:(==)(qn1::QN, qn2::QN; assume_filled=false)
if !assume_filled
qn1, qn2 = fillqns(qn1, qn2)
end
return isequal_assume_filled(qn1, qn2)
end
function isless_assume_filled(qn1::QN, qn2::QN)
for n in 1:length(qn1)
val1 = val(qn1[n])
val2 = val(qn2[n])
val1 != val2 && return val1 < val2
end
return false
end
function Base.isless(qn1::QN, qn2::QN; assume_filled=false)
return <(qn1, qn2; assume_filled=assume_filled)
end
function Base.:(<)(qn1::QN, qn2::QN; assume_filled=false)
if !assume_filled
qn1, qn2 = fillqns(qn1, qn2)
end
return isless_assume_filled(qn1, qn2)
end
function have_same_qns(qn1::QN, qn2::QN)
for n in 1:length(qn1)
name(qn1[n]) != name(qn2[n]) && return false
end
return true
end
function have_same_mods(qn1::QN, qn2::QN)
for n in 1:length(qn1)
modulus(qn1[n]) != modulus(qn2[n]) && return false
end
return true
end
function removeqn(qn::QN, qn_name::String)
ss_qn_name = SmallString(qn_name)
# Find the location of the QNVal to remove
n_qn = nothing
for n in 1:length(qn)
qnval = qn[n]
if name(qnval) == ss_qn_name
n_qn = n
end
end
if isnothing(n_qn)
return qn
end
qn_data = data(qn)
for j in n_qn:(length(qn) - 1)
qn_data = Base.setindex(qn_data, qn_data[j + 1], j)
end
qn_data = Base.setindex(qn_data, QNVal(), length(qn))
return QN(qn_data)
end
function Base.show(io::IO, q::QN)
print(io, "QN(")
Na = nactive(q)
for n in 1:Na
v = q[n]
n > 1 && print(io, ",")
Na > 1 && print(io, "(")
if name(v) != SmallString("")
print(io, "\"$(name(v))\",")
end
print(io, "$(val(v))")
if modulus(v) != 1
print(io, ",$(modulus(v))")
end
Na > 1 && print(io, ")")
end
return print(io, ")")
end