TensorFox 1.2.2__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- TensorFox/Alternating_Least_Squares.py +264 -0
- TensorFox/Auxiliar.py +686 -0
- TensorFox/Compression.py +624 -0
- TensorFox/Conversion.py +494 -0
- TensorFox/Critical.py +3320 -0
- TensorFox/Display.py +466 -0
- TensorFox/GaussNewton.py +811 -0
- TensorFox/Initialization.py +386 -0
- TensorFox/MultilinearAlgebra.py +649 -0
- TensorFox/TensorFox.py +1194 -0
- TensorFox/TensorLearning.py +1103 -0
- TensorFox/__init__.py +7 -0
- tensorfox-1.2.2.dist-info/METADATA +257 -0
- tensorfox-1.2.2.dist-info/RECORD +17 -0
- tensorfox-1.2.2.dist-info/WHEEL +5 -0
- tensorfox-1.2.2.dist-info/licenses/LICENSE +674 -0
- tensorfox-1.2.2.dist-info/top_level.txt +1 -0
TensorFox/Critical.py
ADDED
|
@@ -0,0 +1,3320 @@
|
|
|
1
|
+
"""
|
|
2
|
+
Critical Module
|
|
3
|
+
===============
|
|
4
|
+
This module is responsible for the most costly parts of Tensor Fox.
|
|
5
|
+
"""
|
|
6
|
+
|
|
7
|
+
import numpy as np
|
|
8
|
+
from numpy import dot, empty, zeros, float64, array, linspace, where
|
|
9
|
+
from numpy.linalg import norm
|
|
10
|
+
from numba import njit, prange
|
|
11
|
+
from scipy.sparse import coo_matrix
|
|
12
|
+
|
|
13
|
+
|
|
14
|
+
@njit(nogil=True, parallel=True)
|
|
15
|
+
def fastnorm(A, B):
|
|
16
|
+
m, n = A.shape
|
|
17
|
+
s = 0.0
|
|
18
|
+
for i in prange(m):
|
|
19
|
+
for j in range(n):
|
|
20
|
+
s += (A[i, j] - B[i, j])**2
|
|
21
|
+
s = np.sqrt(s)
|
|
22
|
+
return s
|
|
23
|
+
|
|
24
|
+
|
|
25
|
+
def sparse_fastnorm(data, idxs, dims, factors):
|
|
26
|
+
"""
|
|
27
|
+
This function computes the error between the nonzero entries in data and their corresponding approximations given
|
|
28
|
+
by the factor matrices. The zero entries are not taken in account.
|
|
29
|
+
"""
|
|
30
|
+
|
|
31
|
+
R = factors[0].shape[1]
|
|
32
|
+
L = len(dims)
|
|
33
|
+
nnz = len(idxs)
|
|
34
|
+
|
|
35
|
+
data_approx_cols = zeros((nnz, R))
|
|
36
|
+
data_approx_cols = sparse_fastnorm_computations(data_approx_cols, idxs, factors, R, L, nnz)
|
|
37
|
+
data_approx = np.sum(data_approx_cols, axis=1)
|
|
38
|
+
s = norm(data - data_approx)
|
|
39
|
+
|
|
40
|
+
return s
|
|
41
|
+
|
|
42
|
+
|
|
43
|
+
@njit(nogil=True, parallel=True)
|
|
44
|
+
def sparse_fastnorm_computations(data_approx_cols, idxs, factors, R, L, nnz):
|
|
45
|
+
for r in prange(R):
|
|
46
|
+
for i in range(nnz):
|
|
47
|
+
j = idxs[i]
|
|
48
|
+
p = 1
|
|
49
|
+
for l in range(L):
|
|
50
|
+
p *= factors[l][j[l], r]
|
|
51
|
+
data_approx_cols[i, r] += p
|
|
52
|
+
|
|
53
|
+
return data_approx_cols
|
|
54
|
+
|
|
55
|
+
|
|
56
|
+
def sparse_dot_inner(piece, A):
|
|
57
|
+
"""
|
|
58
|
+
Subroutine of the function sparse_dot (module MultilinearAlgebra). Here is where the actual computations are made.
|
|
59
|
+
"""
|
|
60
|
+
|
|
61
|
+
data_tmp = []
|
|
62
|
+
idxs_tmp = []
|
|
63
|
+
a, b, proc_id = piece
|
|
64
|
+
|
|
65
|
+
# Define matrix variables.
|
|
66
|
+
n = A.shape[0]
|
|
67
|
+
A_row_idxs = [set(A[i, :].indices) for i in range(n)]
|
|
68
|
+
B = A.tocoo()
|
|
69
|
+
A_dct = {(B.row[i], B.col[i]): B.data[i] for i in range(len(B.data))}
|
|
70
|
+
rows = set([x[0] for x in A_dct]).intersection(range(a, b))
|
|
71
|
+
B = []
|
|
72
|
+
|
|
73
|
+
for i in rows:
|
|
74
|
+
for j in rows.intersection(range(i)):
|
|
75
|
+
idx = A_row_idxs[i].intersection(A_row_idxs[j])
|
|
76
|
+
val = sum([A_dct[(i, k)] * A_dct[(j, k)] for k in idx])
|
|
77
|
+
if val != 0:
|
|
78
|
+
data_tmp.append(val)
|
|
79
|
+
idxs_tmp.append([i, j])
|
|
80
|
+
# Put the value on the other half of the matrix since it is symmetric.
|
|
81
|
+
data_tmp.append(val)
|
|
82
|
+
idxs_tmp.append([j, i])
|
|
83
|
+
|
|
84
|
+
return data_tmp, idxs_tmp
|
|
85
|
+
|
|
86
|
+
|
|
87
|
+
def dense_sparse_dot_inner(piece, A, B, display):
|
|
88
|
+
"""
|
|
89
|
+
Subroutine of the function dense_sparse_dot (module MultilinearAlgebra). Here is where the actual computations are made.
|
|
90
|
+
"""
|
|
91
|
+
|
|
92
|
+
data_tmp = []
|
|
93
|
+
idxs_tmp = []
|
|
94
|
+
a, b, proc_id = piece
|
|
95
|
+
|
|
96
|
+
# Define matrix variables.
|
|
97
|
+
m = A.shape[0]
|
|
98
|
+
n = B.shape[1]
|
|
99
|
+
pct = array([int(x) for x in linspace(0, m, 101)])
|
|
100
|
+
B_col_idxs = {j: set(B[:, j].nonzero()[0]) for j in B.nonzero()[1]}
|
|
101
|
+
cols = set(B.nonzero()[1]).intersection(range(a, b))
|
|
102
|
+
|
|
103
|
+
|
|
104
|
+
for i in range(m):
|
|
105
|
+
for j in cols:
|
|
106
|
+
idx = B_col_idxs[j]
|
|
107
|
+
val = sum([A[i, k] * B[k, j] for k in idx])
|
|
108
|
+
if val != 0:
|
|
109
|
+
data_tmp.append(val)
|
|
110
|
+
idxs_tmp.append([i, j])
|
|
111
|
+
# Display % progress on the screen. Only works when the user is running the program in the terminal.
|
|
112
|
+
idx_pct = where(pct==i)
|
|
113
|
+
if display > 1 and len(idx_pct) > 0:
|
|
114
|
+
if len(idx_pct[0]) > 0:
|
|
115
|
+
print('dense_sparse_dot - Process', proc_id, ': ', idx_pct[0][0], ' %')
|
|
116
|
+
|
|
117
|
+
if display > 1:
|
|
118
|
+
print('dense_sparse_dot - Process', proc_id, ': ', '100 %')
|
|
119
|
+
|
|
120
|
+
return data_tmp, idxs_tmp
|
|
121
|
+
|
|
122
|
+
|
|
123
|
+
@njit(nogil=True, parallel=True)
|
|
124
|
+
def unfold1_order3(T, Tl, dims):
|
|
125
|
+
I0, I1, I2 = dims
|
|
126
|
+
for i2 in prange(I2):
|
|
127
|
+
for i1 in range(I1):
|
|
128
|
+
s = i2*I1 + i1
|
|
129
|
+
Tl[:,s] = T[:, i1, i2]
|
|
130
|
+
return Tl
|
|
131
|
+
|
|
132
|
+
|
|
133
|
+
@njit(nogil=True, parallel=True)
|
|
134
|
+
def unfold2_order3(T, Tl, dims):
|
|
135
|
+
I0, I1, I2 = dims
|
|
136
|
+
for i2 in prange(I2):
|
|
137
|
+
for i0 in range(I0):
|
|
138
|
+
s = i2*I0 + i0
|
|
139
|
+
Tl[:,s] = T[i0, :, i2]
|
|
140
|
+
return Tl
|
|
141
|
+
|
|
142
|
+
|
|
143
|
+
@njit(nogil=True, parallel=True)
|
|
144
|
+
def unfold3_order3(T, Tl, dims):
|
|
145
|
+
I0, I1, I2 = dims
|
|
146
|
+
for i1 in prange(I1):
|
|
147
|
+
for i0 in range(I0):
|
|
148
|
+
s = i1*I0 + i0
|
|
149
|
+
Tl[:,s] = T[i0, i1, :]
|
|
150
|
+
return Tl
|
|
151
|
+
|
|
152
|
+
|
|
153
|
+
@njit(nogil=True, parallel=True)
|
|
154
|
+
def unfold1_order4(T, Tl, dims):
|
|
155
|
+
I0, I1, I2, I3 = dims
|
|
156
|
+
for i3 in prange(I3):
|
|
157
|
+
for i2 in range(I2):
|
|
158
|
+
for i1 in range(I1):
|
|
159
|
+
s = i3*I1*I2 + i2*I1 + i1
|
|
160
|
+
Tl[:,s] = T[:, i1, i2, i3]
|
|
161
|
+
return Tl
|
|
162
|
+
|
|
163
|
+
|
|
164
|
+
@njit(nogil=True, parallel=True)
|
|
165
|
+
def unfold2_order4(T, Tl, dims):
|
|
166
|
+
I0, I1, I2, I3 = dims
|
|
167
|
+
for i3 in prange(I3):
|
|
168
|
+
for i2 in range(I2):
|
|
169
|
+
for i0 in range(I0):
|
|
170
|
+
s = i3*I0*I2 + i2*I0 + i0
|
|
171
|
+
Tl[:,s] = T[i0, :, i2, i3]
|
|
172
|
+
return Tl
|
|
173
|
+
|
|
174
|
+
|
|
175
|
+
@njit(nogil=True, parallel=True)
|
|
176
|
+
def unfold3_order4(T, Tl, dims):
|
|
177
|
+
I0, I1, I2, I3 = dims
|
|
178
|
+
for i3 in prange(I3):
|
|
179
|
+
for i1 in range(I1):
|
|
180
|
+
for i0 in range(I0):
|
|
181
|
+
s = i3*I0*I1 + i1*I0 + i0
|
|
182
|
+
Tl[:,s] = T[i0, i1, :, i3]
|
|
183
|
+
return Tl
|
|
184
|
+
|
|
185
|
+
|
|
186
|
+
@njit(nogil=True, parallel=True)
|
|
187
|
+
def unfold4_order4(T, Tl, dims):
|
|
188
|
+
I0, I1, I2, I3 = dims
|
|
189
|
+
for i2 in prange(I2):
|
|
190
|
+
for i1 in range(I1):
|
|
191
|
+
for i0 in range(I0):
|
|
192
|
+
s = i2*I0*I1 + i1*I0 + i0
|
|
193
|
+
Tl[:,s] = T[i0, i1, i2, :]
|
|
194
|
+
return Tl
|
|
195
|
+
|
|
196
|
+
|
|
197
|
+
@njit(nogil=True, parallel=True)
|
|
198
|
+
def unfold1_order5(T, Tl, dims):
|
|
199
|
+
I0, I1, I2, I3, I4 = dims
|
|
200
|
+
for i4 in prange(I4):
|
|
201
|
+
for i3 in range(I3):
|
|
202
|
+
for i2 in range(I2):
|
|
203
|
+
for i1 in range(I1):
|
|
204
|
+
s = i4*I1*I2*I3 + i3*I1*I2 + i2*I1 + i1
|
|
205
|
+
Tl[:,s] = T[:, i1, i2, i3, i4]
|
|
206
|
+
return Tl
|
|
207
|
+
|
|
208
|
+
|
|
209
|
+
@njit(nogil=True, parallel=True)
|
|
210
|
+
def unfold2_order5(T, Tl, dims):
|
|
211
|
+
I0, I1, I2, I3, I4 = dims
|
|
212
|
+
for i4 in prange(I4):
|
|
213
|
+
for i3 in range(I3):
|
|
214
|
+
for i2 in range(I2):
|
|
215
|
+
for i0 in range(I0):
|
|
216
|
+
s = i4*I0*I2*I3 + i3*I0*I2 + i2*I0 + i0
|
|
217
|
+
Tl[:,s] = T[i0, :, i2, i3, i4]
|
|
218
|
+
return Tl
|
|
219
|
+
|
|
220
|
+
|
|
221
|
+
@njit(nogil=True, parallel=True)
|
|
222
|
+
def unfold3_order5(T, Tl, dims):
|
|
223
|
+
I0, I1, I2, I3, I4 = dims
|
|
224
|
+
for i4 in prange(I4):
|
|
225
|
+
for i3 in range(I3):
|
|
226
|
+
for i1 in range(I1):
|
|
227
|
+
for i0 in range(I0):
|
|
228
|
+
s = i4*I0*I1*I3 + i3*I0*I1 + i1*I0 + i0
|
|
229
|
+
Tl[:,s] = T[i0, i1, :, i3, i4]
|
|
230
|
+
return Tl
|
|
231
|
+
|
|
232
|
+
|
|
233
|
+
@njit(nogil=True, parallel=True)
|
|
234
|
+
def unfold4_order5(T, Tl, dims):
|
|
235
|
+
I0, I1, I2, I3, I4 = dims
|
|
236
|
+
for i4 in prange(I4):
|
|
237
|
+
for i2 in range(I2):
|
|
238
|
+
for i1 in range(I1):
|
|
239
|
+
for i0 in range(I0):
|
|
240
|
+
s = i4*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
241
|
+
Tl[:,s] = T[i0, i1, i2, :, i4]
|
|
242
|
+
return Tl
|
|
243
|
+
|
|
244
|
+
|
|
245
|
+
@njit(nogil=True, parallel=True)
|
|
246
|
+
def unfold5_order5(T, Tl, dims):
|
|
247
|
+
I0, I1, I2, I3, I4 = dims
|
|
248
|
+
for i3 in prange(I3):
|
|
249
|
+
for i2 in range(I2):
|
|
250
|
+
for i1 in range(I1):
|
|
251
|
+
for i0 in range(I0):
|
|
252
|
+
s = i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
253
|
+
Tl[:,s] = T[i0, i1, i2, i3, :]
|
|
254
|
+
return Tl
|
|
255
|
+
|
|
256
|
+
|
|
257
|
+
@njit(nogil=True, parallel=True)
|
|
258
|
+
def unfold1_order6(T, Tl, dims):
|
|
259
|
+
I0, I1, I2, I3, I4, I5 = dims
|
|
260
|
+
for i5 in prange(I5):
|
|
261
|
+
for i4 in range(I4):
|
|
262
|
+
for i3 in range(I3):
|
|
263
|
+
for i2 in range(I2):
|
|
264
|
+
for i1 in range(I1):
|
|
265
|
+
s = i5*I1*I2*I3*I4 + i4*I1*I2*I3 + i3*I1*I2 + i2*I1 + i1
|
|
266
|
+
Tl[:,s] = T[:, i1, i2, i3, i4, i5]
|
|
267
|
+
return Tl
|
|
268
|
+
|
|
269
|
+
|
|
270
|
+
@njit(nogil=True, parallel=True)
|
|
271
|
+
def unfold2_order6(T, Tl, dims):
|
|
272
|
+
I0, I1, I2, I3, I4, I5 = dims
|
|
273
|
+
for i5 in prange(I5):
|
|
274
|
+
for i4 in range(I4):
|
|
275
|
+
for i3 in range(I3):
|
|
276
|
+
for i2 in range(I2):
|
|
277
|
+
for i0 in range(I0):
|
|
278
|
+
s = i5*I0*I2*I3*I4 + i4*I0*I2*I3 + i3*I0*I2 + i2*I0 + i0
|
|
279
|
+
Tl[:,s] = T[i0, :, i2, i3, i4, i5]
|
|
280
|
+
return Tl
|
|
281
|
+
|
|
282
|
+
|
|
283
|
+
@njit(nogil=True, parallel=True)
|
|
284
|
+
def unfold3_order6(T, Tl, dims):
|
|
285
|
+
I0, I1, I2, I3, I4, I5 = dims
|
|
286
|
+
for i5 in prange(I5):
|
|
287
|
+
for i4 in range(I4):
|
|
288
|
+
for i3 in range(I3):
|
|
289
|
+
for i1 in range(I1):
|
|
290
|
+
for i0 in range(I0):
|
|
291
|
+
s = i5*I0*I1*I3*I4 + i4*I0*I1*I3 + i3*I0*I1 + i1*I0 + i0
|
|
292
|
+
Tl[:,s] = T[i0, i1, :, i3, i4, i5]
|
|
293
|
+
return Tl
|
|
294
|
+
|
|
295
|
+
|
|
296
|
+
@njit(nogil=True, parallel=True)
|
|
297
|
+
def unfold4_order6(T, Tl, dims):
|
|
298
|
+
I0, I1, I2, I3, I4, I5 = dims
|
|
299
|
+
for i5 in prange(I5):
|
|
300
|
+
for i4 in range(I4):
|
|
301
|
+
for i2 in range(I2):
|
|
302
|
+
for i1 in range(I1):
|
|
303
|
+
for i0 in range(I0):
|
|
304
|
+
s = i5*I0*I1*I2*I4 + i4*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
305
|
+
Tl[:,s] = T[i0, i1, i2, :, i4, i5]
|
|
306
|
+
return Tl
|
|
307
|
+
|
|
308
|
+
|
|
309
|
+
@njit(nogil=True, parallel=True)
|
|
310
|
+
def unfold5_order6(T, Tl, dims):
|
|
311
|
+
I0, I1, I2, I3, I4, I5 = dims
|
|
312
|
+
for i5 in prange(I5):
|
|
313
|
+
for i3 in range(I3):
|
|
314
|
+
for i2 in range(I2):
|
|
315
|
+
for i1 in range(I1):
|
|
316
|
+
for i0 in range(I0):
|
|
317
|
+
s = i5*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
318
|
+
Tl[:,s] = T[i0, i1, i2, i3, :, i5]
|
|
319
|
+
return Tl
|
|
320
|
+
|
|
321
|
+
|
|
322
|
+
@njit(nogil=True, parallel=True)
|
|
323
|
+
def unfold6_order6(T, Tl, dims):
|
|
324
|
+
I0, I1, I2, I3, I4, I5 = dims
|
|
325
|
+
for i4 in prange(I4):
|
|
326
|
+
for i3 in range(I3):
|
|
327
|
+
for i2 in range(I2):
|
|
328
|
+
for i1 in range(I1):
|
|
329
|
+
for i0 in range(I0):
|
|
330
|
+
s = i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
331
|
+
Tl[:,s] = T[i0, i1, i2, i3, i4, :]
|
|
332
|
+
return Tl
|
|
333
|
+
|
|
334
|
+
|
|
335
|
+
@njit(nogil=True, parallel=True)
|
|
336
|
+
def unfold1_order7(T, Tl, dims):
|
|
337
|
+
I0, I1, I2, I3, I4, I5, I6 = dims
|
|
338
|
+
for i6 in prange(I6):
|
|
339
|
+
for i5 in range(I5):
|
|
340
|
+
for i4 in range(I4):
|
|
341
|
+
for i3 in range(I3):
|
|
342
|
+
for i2 in range(I2):
|
|
343
|
+
for i1 in range(I1):
|
|
344
|
+
s = i6*I1*I2*I3*I4*I5 + i5*I1*I2*I3*I4 + i4*I1*I2*I3 + i3*I1*I2 + i2*I1 + i1
|
|
345
|
+
Tl[:,s] = T[:, i1, i2, i3, i4, i5, i6]
|
|
346
|
+
return Tl
|
|
347
|
+
|
|
348
|
+
|
|
349
|
+
@njit(nogil=True, parallel=True)
|
|
350
|
+
def unfold2_order7(T, Tl, dims):
|
|
351
|
+
I0, I1, I2, I3, I4, I5, I6 = dims
|
|
352
|
+
for i6 in prange(I6):
|
|
353
|
+
for i5 in range(I5):
|
|
354
|
+
for i4 in range(I4):
|
|
355
|
+
for i3 in range(I3):
|
|
356
|
+
for i2 in range(I2):
|
|
357
|
+
for i0 in range(I0):
|
|
358
|
+
s = i6*I0*I2*I3*I4*I5 + i5*I0*I2*I3*I4 + i4*I0*I2*I3 + i3*I0*I2 + i2*I0 + i0
|
|
359
|
+
Tl[:,s] = T[i0, :, i2, i3, i4, i5, i6]
|
|
360
|
+
return Tl
|
|
361
|
+
|
|
362
|
+
|
|
363
|
+
@njit(nogil=True, parallel=True)
|
|
364
|
+
def unfold3_order7(T, Tl, dims):
|
|
365
|
+
I0, I1, I2, I3, I4, I5, I6 = dims
|
|
366
|
+
for i6 in prange(I6):
|
|
367
|
+
for i5 in range(I5):
|
|
368
|
+
for i4 in range(I4):
|
|
369
|
+
for i3 in range(I3):
|
|
370
|
+
for i1 in range(I1):
|
|
371
|
+
for i0 in range(I0):
|
|
372
|
+
s = i6*I0*I1*I3*I4*I5 + i5*I0*I1*I3*I4 + i4*I0*I1*I3 + i3*I0*I1 + i1*I0 + i0
|
|
373
|
+
Tl[:,s] = T[i0, i1, :, i3, i4, i5, i6]
|
|
374
|
+
return Tl
|
|
375
|
+
|
|
376
|
+
|
|
377
|
+
@njit(nogil=True, parallel=True)
|
|
378
|
+
def unfold4_order7(T, Tl, dims):
|
|
379
|
+
I0, I1, I2, I3, I4, I5, I6 = dims
|
|
380
|
+
for i6 in prange(I6):
|
|
381
|
+
for i5 in range(I5):
|
|
382
|
+
for i4 in range(I4):
|
|
383
|
+
for i2 in range(I2):
|
|
384
|
+
for i1 in range(I1):
|
|
385
|
+
for i0 in range(I0):
|
|
386
|
+
s = i6*I0*I1*I2*I4*I5 + i5*I0*I1*I2*I4 + i4*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
387
|
+
Tl[:,s] = T[i0, i1, i2, :, i4, i5, i6]
|
|
388
|
+
return Tl
|
|
389
|
+
|
|
390
|
+
|
|
391
|
+
@njit(nogil=True, parallel=True)
|
|
392
|
+
def unfold5_order7(T, Tl, dims):
|
|
393
|
+
I0, I1, I2, I3, I4, I5, I6 = dims
|
|
394
|
+
for i6 in prange(I6):
|
|
395
|
+
for i5 in range(I5):
|
|
396
|
+
for i3 in range(I3):
|
|
397
|
+
for i2 in range(I2):
|
|
398
|
+
for i1 in range(I1):
|
|
399
|
+
for i0 in range(I0):
|
|
400
|
+
s = i6*I0*I1*I2*I3*I5 + i5*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
401
|
+
Tl[:,s] = T[i0, i1, i2, i3, :, i5, i6]
|
|
402
|
+
return Tl
|
|
403
|
+
|
|
404
|
+
|
|
405
|
+
@njit(nogil=True, parallel=True)
|
|
406
|
+
def unfold6_order7(T, Tl, dims):
|
|
407
|
+
I0, I1, I2, I3, I4, I5, I6 = dims
|
|
408
|
+
for i6 in prange(I6):
|
|
409
|
+
for i4 in range(I4):
|
|
410
|
+
for i3 in range(I3):
|
|
411
|
+
for i2 in range(I2):
|
|
412
|
+
for i1 in range(I1):
|
|
413
|
+
for i0 in range(I0):
|
|
414
|
+
s = i6*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
415
|
+
Tl[:,s] = T[i0, i1, i2, i3, i4, :, i6]
|
|
416
|
+
return Tl
|
|
417
|
+
|
|
418
|
+
|
|
419
|
+
@njit(nogil=True, parallel=True)
|
|
420
|
+
def unfold7_order7(T, Tl, dims):
|
|
421
|
+
I0, I1, I2, I3, I4, I5, I6 = dims
|
|
422
|
+
for i5 in prange(I5):
|
|
423
|
+
for i4 in range(I4):
|
|
424
|
+
for i3 in range(I3):
|
|
425
|
+
for i2 in range(I2):
|
|
426
|
+
for i1 in range(I1):
|
|
427
|
+
for i0 in range(I0):
|
|
428
|
+
s = i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
429
|
+
Tl[:,s] = T[i0, i1, i2, i3, i4, i5, :]
|
|
430
|
+
return Tl
|
|
431
|
+
|
|
432
|
+
|
|
433
|
+
@njit(nogil=True, parallel=True)
|
|
434
|
+
def unfold1_order8(T, Tl, dims):
|
|
435
|
+
I0, I1, I2, I3, I4, I5, I6, I7 = dims
|
|
436
|
+
for i7 in prange(I7):
|
|
437
|
+
for i6 in range(I6):
|
|
438
|
+
for i5 in range(I5):
|
|
439
|
+
for i4 in range(I4):
|
|
440
|
+
for i3 in range(I3):
|
|
441
|
+
for i2 in range(I2):
|
|
442
|
+
for i1 in range(I1):
|
|
443
|
+
s = i7*I1*I2*I3*I4*I5*I6 + i6*I1*I2*I3*I4*I5 + i5*I1*I2*I3*I4 + i4*I1*I2*I3 + i3*I1*I2 + i2*I1 + i1
|
|
444
|
+
Tl[:,s] = T[:, i1, i2, i3, i4, i5, i6, i7]
|
|
445
|
+
return Tl
|
|
446
|
+
|
|
447
|
+
|
|
448
|
+
@njit(nogil=True, parallel=True)
|
|
449
|
+
def unfold2_order8(T, Tl, dims):
|
|
450
|
+
I0, I1, I2, I3, I4, I5, I6, I7 = dims
|
|
451
|
+
for i7 in prange(I7):
|
|
452
|
+
for i6 in range(I6):
|
|
453
|
+
for i5 in range(I5):
|
|
454
|
+
for i4 in range(I4):
|
|
455
|
+
for i3 in range(I3):
|
|
456
|
+
for i2 in range(I2):
|
|
457
|
+
for i0 in range(I0):
|
|
458
|
+
s = i7*I0*I2*I3*I4*I5*I6 + i6*I0*I2*I3*I4*I5 + i5*I0*I2*I3*I4 + i4*I0*I2*I3 + i3*I0*I2 + i2*I0 + i0
|
|
459
|
+
Tl[:,s] = T[i0, :, i2, i3, i4, i5, i6, i7]
|
|
460
|
+
return Tl
|
|
461
|
+
|
|
462
|
+
|
|
463
|
+
@njit(nogil=True, parallel=True)
|
|
464
|
+
def unfold3_order8(T, Tl, dims):
|
|
465
|
+
I0, I1, I2, I3, I4, I5, I6, I7 = dims
|
|
466
|
+
for i7 in prange(I7):
|
|
467
|
+
for i6 in range(I6):
|
|
468
|
+
for i5 in range(I5):
|
|
469
|
+
for i4 in range(I4):
|
|
470
|
+
for i3 in range(I3):
|
|
471
|
+
for i1 in range(I1):
|
|
472
|
+
for i0 in range(I0):
|
|
473
|
+
s = i7*I0*I1*I3*I4*I5*I6 + i6*I0*I1*I3*I4*I5 + i5*I0*I1*I3*I4 + i4*I0*I1*I3 + i3*I0*I1 + i1*I0 + i0
|
|
474
|
+
Tl[:,s] = T[i0, i1, :, i3, i4, i5, i6, i7]
|
|
475
|
+
return Tl
|
|
476
|
+
|
|
477
|
+
|
|
478
|
+
@njit(nogil=True, parallel=True)
|
|
479
|
+
def unfold4_order8(T, Tl, dims):
|
|
480
|
+
I0, I1, I2, I3, I4, I5, I6, I7 = dims
|
|
481
|
+
for i7 in prange(I7):
|
|
482
|
+
for i6 in range(I6):
|
|
483
|
+
for i5 in range(I5):
|
|
484
|
+
for i4 in range(I4):
|
|
485
|
+
for i2 in range(I2):
|
|
486
|
+
for i1 in range(I1):
|
|
487
|
+
for i0 in range(I0):
|
|
488
|
+
s = i7*I0*I1*I2*I4*I5*I6 + i6*I0*I1*I2*I4*I5 + i5*I0*I1*I2*I4 + i4*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
489
|
+
Tl[:,s] = T[i0, i1, i2, :, i4, i5, i6, i7]
|
|
490
|
+
return Tl
|
|
491
|
+
|
|
492
|
+
|
|
493
|
+
@njit(nogil=True, parallel=True)
|
|
494
|
+
def unfold5_order8(T, Tl, dims):
|
|
495
|
+
I0, I1, I2, I3, I4, I5, I6, I7 = dims
|
|
496
|
+
for i7 in prange(I7):
|
|
497
|
+
for i6 in range(I6):
|
|
498
|
+
for i5 in range(I5):
|
|
499
|
+
for i3 in range(I3):
|
|
500
|
+
for i2 in range(I2):
|
|
501
|
+
for i1 in range(I1):
|
|
502
|
+
for i0 in range(I0):
|
|
503
|
+
s = i7*I0*I1*I2*I3*I5*I6 + i6*I0*I1*I2*I3*I5 + i5*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
504
|
+
Tl[:,s] = T[i0, i1, i2, i3, :, i5, i6, i7]
|
|
505
|
+
return Tl
|
|
506
|
+
|
|
507
|
+
|
|
508
|
+
@njit(nogil=True, parallel=True)
|
|
509
|
+
def unfold6_order8(T, Tl, dims):
|
|
510
|
+
I0, I1, I2, I3, I4, I5, I6, I7 = dims
|
|
511
|
+
for i7 in prange(I7):
|
|
512
|
+
for i6 in range(I6):
|
|
513
|
+
for i4 in range(I4):
|
|
514
|
+
for i3 in range(I3):
|
|
515
|
+
for i2 in range(I2):
|
|
516
|
+
for i1 in range(I1):
|
|
517
|
+
for i0 in range(I0):
|
|
518
|
+
s = i7*I0*I1*I2*I3*I4*I6 + i6*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
519
|
+
Tl[:,s] = T[i0, i1, i2, i3, i4, :, i6, i7]
|
|
520
|
+
return Tl
|
|
521
|
+
|
|
522
|
+
|
|
523
|
+
@njit(nogil=True, parallel=True)
|
|
524
|
+
def unfold7_order8(T, Tl, dims):
|
|
525
|
+
I0, I1, I2, I3, I4, I5, I6, I7 = dims
|
|
526
|
+
for i7 in prange(I7):
|
|
527
|
+
for i5 in range(I5):
|
|
528
|
+
for i4 in range(I4):
|
|
529
|
+
for i3 in range(I3):
|
|
530
|
+
for i2 in range(I2):
|
|
531
|
+
for i1 in range(I1):
|
|
532
|
+
for i0 in range(I0):
|
|
533
|
+
s = i7*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
534
|
+
Tl[:,s] = T[i0, i1, i2, i3, i4, i5, :, i7]
|
|
535
|
+
return Tl
|
|
536
|
+
|
|
537
|
+
|
|
538
|
+
@njit(nogil=True, parallel=True)
|
|
539
|
+
def unfold8_order8(T, Tl, dims):
|
|
540
|
+
I0, I1, I2, I3, I4, I5, I6, I7 = dims
|
|
541
|
+
for i6 in prange(I6):
|
|
542
|
+
for i5 in range(I5):
|
|
543
|
+
for i4 in range(I4):
|
|
544
|
+
for i3 in range(I3):
|
|
545
|
+
for i2 in range(I2):
|
|
546
|
+
for i1 in range(I1):
|
|
547
|
+
for i0 in range(I0):
|
|
548
|
+
s = i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
549
|
+
Tl[:,s] = T[i0, i1, i2, i3, i4, i5, i6, :]
|
|
550
|
+
return Tl
|
|
551
|
+
|
|
552
|
+
|
|
553
|
+
@njit(nogil=True, parallel=True)
|
|
554
|
+
def unfold1_order9(T, Tl, dims):
|
|
555
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8 = dims
|
|
556
|
+
for i8 in prange(I8):
|
|
557
|
+
for i7 in range(I7):
|
|
558
|
+
for i6 in range(I6):
|
|
559
|
+
for i5 in range(I5):
|
|
560
|
+
for i4 in range(I4):
|
|
561
|
+
for i3 in range(I3):
|
|
562
|
+
for i2 in range(I2):
|
|
563
|
+
for i1 in range(I1):
|
|
564
|
+
s = i8*I1*I2*I3*I4*I5*I6*I7 + i7*I1*I2*I3*I4*I5*I6 + i6*I1*I2*I3*I4*I5 + i5*I1*I2*I3*I4 + i4*I1*I2*I3 + i3*I1*I2 + i2*I1 + i1
|
|
565
|
+
Tl[:,s] = T[:, i1, i2, i3, i4, i5, i6, i7, i8]
|
|
566
|
+
return Tl
|
|
567
|
+
|
|
568
|
+
|
|
569
|
+
@njit(nogil=True, parallel=True)
|
|
570
|
+
def unfold2_order9(T, Tl, dims):
|
|
571
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8 = dims
|
|
572
|
+
for i8 in prange(I8):
|
|
573
|
+
for i7 in range(I7):
|
|
574
|
+
for i6 in range(I6):
|
|
575
|
+
for i5 in range(I5):
|
|
576
|
+
for i4 in range(I4):
|
|
577
|
+
for i3 in range(I3):
|
|
578
|
+
for i2 in range(I2):
|
|
579
|
+
for i0 in range(I0):
|
|
580
|
+
s = i8*I0*I2*I3*I4*I5*I6*I7 + i7*I0*I2*I3*I4*I5*I6 + i6*I0*I2*I3*I4*I5 + i5*I0*I2*I3*I4 + i4*I0*I2*I3 + i3*I0*I2 + i2*I0 + i0
|
|
581
|
+
Tl[:,s] = T[i0, :, i2, i3, i4, i5, i6, i7, i8]
|
|
582
|
+
return Tl
|
|
583
|
+
|
|
584
|
+
|
|
585
|
+
@njit(nogil=True, parallel=True)
|
|
586
|
+
def unfold3_order9(T, Tl, dims):
|
|
587
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8 = dims
|
|
588
|
+
for i8 in prange(I8):
|
|
589
|
+
for i7 in range(I7):
|
|
590
|
+
for i6 in range(I6):
|
|
591
|
+
for i5 in range(I5):
|
|
592
|
+
for i4 in range(I4):
|
|
593
|
+
for i3 in range(I3):
|
|
594
|
+
for i1 in range(I1):
|
|
595
|
+
for i0 in range(I0):
|
|
596
|
+
s = i8*I0*I1*I3*I4*I5*I6*I7 + i7*I0*I1*I3*I4*I5*I6 + i6*I0*I1*I3*I4*I5 + i5*I0*I1*I3*I4 + i4*I0*I1*I3 + i3*I0*I1 + i1*I0 + i0
|
|
597
|
+
Tl[:,s] = T[i0, i1, :, i3, i4, i5, i6, i7, i8]
|
|
598
|
+
return Tl
|
|
599
|
+
|
|
600
|
+
|
|
601
|
+
@njit(nogil=True, parallel=True)
|
|
602
|
+
def unfold4_order9(T, Tl, dims):
|
|
603
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8 = dims
|
|
604
|
+
for i8 in prange(I8):
|
|
605
|
+
for i7 in range(I7):
|
|
606
|
+
for i6 in range(I6):
|
|
607
|
+
for i5 in range(I5):
|
|
608
|
+
for i4 in range(I4):
|
|
609
|
+
for i2 in range(I2):
|
|
610
|
+
for i1 in range(I1):
|
|
611
|
+
for i0 in range(I0):
|
|
612
|
+
s = i8*I0*I1*I2*I4*I5*I6*I7 + i7*I0*I1*I2*I4*I5*I6 + i6*I0*I1*I2*I4*I5 + i5*I0*I1*I2*I4 + i4*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
613
|
+
Tl[:,s] = T[i0, i1, i2, :, i4, i5, i6, i7, i8]
|
|
614
|
+
return Tl
|
|
615
|
+
|
|
616
|
+
|
|
617
|
+
@njit(nogil=True, parallel=True)
|
|
618
|
+
def unfold5_order9(T, Tl, dims):
|
|
619
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8 = dims
|
|
620
|
+
for i8 in prange(I8):
|
|
621
|
+
for i7 in range(I7):
|
|
622
|
+
for i6 in range(I6):
|
|
623
|
+
for i5 in range(I5):
|
|
624
|
+
for i3 in range(I3):
|
|
625
|
+
for i2 in range(I2):
|
|
626
|
+
for i1 in range(I1):
|
|
627
|
+
for i0 in range(I0):
|
|
628
|
+
s = i8*I0*I1*I2*I3*I5*I6*I7 + i7*I0*I1*I2*I3*I5*I6 + i6*I0*I1*I2*I3*I5 + i5*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
629
|
+
Tl[:,s] = T[i0, i1, i2, i3, :, i5, i6, i7, i8]
|
|
630
|
+
return Tl
|
|
631
|
+
|
|
632
|
+
|
|
633
|
+
@njit(nogil=True, parallel=True)
|
|
634
|
+
def unfold6_order9(T, Tl, dims):
|
|
635
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8 = dims
|
|
636
|
+
for i8 in prange(I8):
|
|
637
|
+
for i7 in range(I7):
|
|
638
|
+
for i6 in range(I6):
|
|
639
|
+
for i4 in range(I4):
|
|
640
|
+
for i3 in range(I3):
|
|
641
|
+
for i2 in range(I2):
|
|
642
|
+
for i1 in range(I1):
|
|
643
|
+
for i0 in range(I0):
|
|
644
|
+
s = i8*I0*I1*I2*I3*I4*I6*I7 + i7*I0*I1*I2*I3*I4*I6 + i6*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
645
|
+
Tl[:,s] = T[i0, i1, i2, i3, i4, :, i6, i7, i8]
|
|
646
|
+
return Tl
|
|
647
|
+
|
|
648
|
+
|
|
649
|
+
@njit(nogil=True, parallel=True)
|
|
650
|
+
def unfold7_order9(T, Tl, dims):
|
|
651
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8 = dims
|
|
652
|
+
for i8 in prange(I8):
|
|
653
|
+
for i7 in range(I7):
|
|
654
|
+
for i5 in range(I5):
|
|
655
|
+
for i4 in range(I4):
|
|
656
|
+
for i3 in range(I3):
|
|
657
|
+
for i2 in range(I2):
|
|
658
|
+
for i1 in range(I1):
|
|
659
|
+
for i0 in range(I0):
|
|
660
|
+
s = i8*I0*I1*I2*I3*I4*I5*I7 + i7*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
661
|
+
Tl[:,s] = T[i0, i1, i2, i3, i4, i5, :, i7, i8]
|
|
662
|
+
return Tl
|
|
663
|
+
|
|
664
|
+
|
|
665
|
+
@njit(nogil=True, parallel=True)
|
|
666
|
+
def unfold8_order9(T, Tl, dims):
|
|
667
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8 = dims
|
|
668
|
+
for i8 in prange(I8):
|
|
669
|
+
for i6 in range(I6):
|
|
670
|
+
for i5 in range(I5):
|
|
671
|
+
for i4 in range(I4):
|
|
672
|
+
for i3 in range(I3):
|
|
673
|
+
for i2 in range(I2):
|
|
674
|
+
for i1 in range(I1):
|
|
675
|
+
for i0 in range(I0):
|
|
676
|
+
s = i8*I0*I1*I2*I3*I4*I5*I6 + i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
677
|
+
Tl[:,s] = T[i0, i1, i2, i3, i4, i5, i6, :, i8]
|
|
678
|
+
return Tl
|
|
679
|
+
|
|
680
|
+
|
|
681
|
+
@njit(nogil=True, parallel=True)
|
|
682
|
+
def unfold9_order9(T, Tl, dims):
|
|
683
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8 = dims
|
|
684
|
+
for i7 in prange(I7):
|
|
685
|
+
for i6 in range(I6):
|
|
686
|
+
for i5 in range(I5):
|
|
687
|
+
for i4 in range(I4):
|
|
688
|
+
for i3 in range(I3):
|
|
689
|
+
for i2 in range(I2):
|
|
690
|
+
for i1 in range(I1):
|
|
691
|
+
for i0 in range(I0):
|
|
692
|
+
s = i7*I0*I1*I2*I3*I4*I5*I6 + i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
693
|
+
Tl[:,s] = T[i0, i1, i2, i3, i4, i5, i6, i7, :]
|
|
694
|
+
return Tl
|
|
695
|
+
|
|
696
|
+
|
|
697
|
+
@njit(nogil=True, parallel=True)
|
|
698
|
+
def unfold1_order10(T, Tl, dims):
|
|
699
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 = dims
|
|
700
|
+
for i9 in prange(I9):
|
|
701
|
+
for i8 in range(I8):
|
|
702
|
+
for i7 in range(I7):
|
|
703
|
+
for i6 in range(I6):
|
|
704
|
+
for i5 in range(I5):
|
|
705
|
+
for i4 in range(I4):
|
|
706
|
+
for i3 in range(I3):
|
|
707
|
+
for i2 in range(I2):
|
|
708
|
+
for i1 in range(I1):
|
|
709
|
+
s = i9*I1*I2*I3*I4*I5*I6*I7*I8 + i8*I1*I2*I3*I4*I5*I6*I7 + i7*I1*I2*I3*I4*I5*I6 + i6*I1*I2*I3*I4*I5 + i5*I1*I2*I3*I4 + i4*I1*I2*I3 + i3*I1*I2 + i2*I1 + i1
|
|
710
|
+
Tl[:,s] = T[:, i1, i2, i3, i4, i5, i6, i7, i8, i9]
|
|
711
|
+
return Tl
|
|
712
|
+
|
|
713
|
+
|
|
714
|
+
@njit(nogil=True, parallel=True)
|
|
715
|
+
def unfold2_order10(T, Tl, dims):
|
|
716
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 = dims
|
|
717
|
+
for i9 in prange(I9):
|
|
718
|
+
for i8 in range(I8):
|
|
719
|
+
for i7 in range(I7):
|
|
720
|
+
for i6 in range(I6):
|
|
721
|
+
for i5 in range(I5):
|
|
722
|
+
for i4 in range(I4):
|
|
723
|
+
for i3 in range(I3):
|
|
724
|
+
for i2 in range(I2):
|
|
725
|
+
for i0 in range(I0):
|
|
726
|
+
s = i9*I0*I2*I3*I4*I5*I6*I7*I8 + i8*I0*I2*I3*I4*I5*I6*I7 + i7*I0*I2*I3*I4*I5*I6 + i6*I0*I2*I3*I4*I5 + i5*I0*I2*I3*I4 + i4*I0*I2*I3 + i3*I0*I2 + i2*I0 + i0
|
|
727
|
+
Tl[:,s] = T[i0, :, i2, i3, i4, i5, i6, i7, i8, i9]
|
|
728
|
+
return Tl
|
|
729
|
+
|
|
730
|
+
|
|
731
|
+
@njit(nogil=True, parallel=True)
|
|
732
|
+
def unfold3_order10(T, Tl, dims):
|
|
733
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 = dims
|
|
734
|
+
for i9 in prange(I9):
|
|
735
|
+
for i8 in range(I8):
|
|
736
|
+
for i7 in range(I7):
|
|
737
|
+
for i6 in range(I6):
|
|
738
|
+
for i5 in range(I5):
|
|
739
|
+
for i4 in range(I4):
|
|
740
|
+
for i3 in range(I3):
|
|
741
|
+
for i1 in range(I1):
|
|
742
|
+
for i0 in range(I0):
|
|
743
|
+
s = i9*I0*I1*I3*I4*I5*I6*I7*I8 + i8*I0*I1*I3*I4*I5*I6*I7 + i7*I0*I1*I3*I4*I5*I6 + i6*I0*I1*I3*I4*I5 + i5*I0*I1*I3*I4 + i4*I0*I1*I3 + i3*I0*I1 + i1*I0 + i0
|
|
744
|
+
Tl[:,s] = T[i0, i1, :, i3, i4, i5, i6, i7, i8, i9]
|
|
745
|
+
return Tl
|
|
746
|
+
|
|
747
|
+
|
|
748
|
+
@njit(nogil=True, parallel=True)
|
|
749
|
+
def unfold4_order10(T, Tl, dims):
|
|
750
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 = dims
|
|
751
|
+
for i9 in prange(I9):
|
|
752
|
+
for i8 in range(I8):
|
|
753
|
+
for i7 in range(I7):
|
|
754
|
+
for i6 in range(I6):
|
|
755
|
+
for i5 in range(I5):
|
|
756
|
+
for i4 in range(I4):
|
|
757
|
+
for i2 in range(I2):
|
|
758
|
+
for i1 in range(I1):
|
|
759
|
+
for i0 in range(I0):
|
|
760
|
+
s = i9*I0*I1*I2*I4*I5*I6*I7*I8 + i8*I0*I1*I2*I4*I5*I6*I7 + i7*I0*I1*I2*I4*I5*I6 + i6*I0*I1*I2*I4*I5 + i5*I0*I1*I2*I4 + i4*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
761
|
+
Tl[:,s] = T[i0, i1, i2, :, i4, i5, i6, i7, i8, i9]
|
|
762
|
+
return Tl
|
|
763
|
+
|
|
764
|
+
|
|
765
|
+
@njit(nogil=True, parallel=True)
|
|
766
|
+
def unfold5_order10(T, Tl, dims):
|
|
767
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 = dims
|
|
768
|
+
for i9 in prange(I9):
|
|
769
|
+
for i8 in range(I8):
|
|
770
|
+
for i7 in range(I7):
|
|
771
|
+
for i6 in range(I6):
|
|
772
|
+
for i5 in range(I5):
|
|
773
|
+
for i3 in range(I3):
|
|
774
|
+
for i2 in range(I2):
|
|
775
|
+
for i1 in range(I1):
|
|
776
|
+
for i0 in range(I0):
|
|
777
|
+
s = i9*I0*I1*I2*I3*I5*I6*I7*I8 + i8*I0*I1*I2*I3*I5*I6*I7 + i7*I0*I1*I2*I3*I5*I6 + i6*I0*I1*I2*I3*I5 + i5*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
778
|
+
Tl[:,s] = T[i0, i1, i2, i3, :, i5, i6, i7, i8, i9]
|
|
779
|
+
return Tl
|
|
780
|
+
|
|
781
|
+
|
|
782
|
+
@njit(nogil=True, parallel=True)
|
|
783
|
+
def unfold6_order10(T, Tl, dims):
|
|
784
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 = dims
|
|
785
|
+
for i9 in prange(I9):
|
|
786
|
+
for i8 in range(I8):
|
|
787
|
+
for i7 in range(I7):
|
|
788
|
+
for i6 in range(I6):
|
|
789
|
+
for i4 in range(I4):
|
|
790
|
+
for i3 in range(I3):
|
|
791
|
+
for i2 in range(I2):
|
|
792
|
+
for i1 in range(I1):
|
|
793
|
+
for i0 in range(I0):
|
|
794
|
+
s = i9*I0*I1*I2*I3*I4*I6*I7*I8 + i8*I0*I1*I2*I3*I4*I6*I7 + i7*I0*I1*I2*I3*I4*I6 + i6*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
795
|
+
Tl[:,s] = T[i0, i1, i2, i3, i4, :, i6, i7, i8, i9]
|
|
796
|
+
return Tl
|
|
797
|
+
|
|
798
|
+
|
|
799
|
+
@njit(nogil=True, parallel=True)
|
|
800
|
+
def unfold7_order10(T, Tl, dims):
|
|
801
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 = dims
|
|
802
|
+
for i9 in prange(I9):
|
|
803
|
+
for i8 in range(I8):
|
|
804
|
+
for i7 in range(I7):
|
|
805
|
+
for i5 in range(I5):
|
|
806
|
+
for i4 in range(I4):
|
|
807
|
+
for i3 in range(I3):
|
|
808
|
+
for i2 in range(I2):
|
|
809
|
+
for i1 in range(I1):
|
|
810
|
+
for i0 in range(I0):
|
|
811
|
+
s = i9*I0*I1*I2*I3*I4*I5*I7*I8 + i8*I0*I1*I2*I3*I4*I5*I7 + i7*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
812
|
+
Tl[:,s] = T[i0, i1, i2, i3, i4, i5, :, i7, i8, i9]
|
|
813
|
+
return Tl
|
|
814
|
+
|
|
815
|
+
|
|
816
|
+
@njit(nogil=True, parallel=True)
|
|
817
|
+
def unfold8_order10(T, Tl, dims):
|
|
818
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 = dims
|
|
819
|
+
for i9 in prange(I9):
|
|
820
|
+
for i8 in range(I8):
|
|
821
|
+
for i6 in range(I6):
|
|
822
|
+
for i5 in range(I5):
|
|
823
|
+
for i4 in range(I4):
|
|
824
|
+
for i3 in range(I3):
|
|
825
|
+
for i2 in range(I2):
|
|
826
|
+
for i1 in range(I1):
|
|
827
|
+
for i0 in range(I0):
|
|
828
|
+
s = i9*I0*I1*I2*I3*I4*I5*I6*I8 + i8*I0*I1*I2*I3*I4*I5*I6 + i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
829
|
+
Tl[:,s] = T[i0, i1, i2, i3, i4, i5, i6, :, i8, i9]
|
|
830
|
+
return Tl
|
|
831
|
+
|
|
832
|
+
|
|
833
|
+
@njit(nogil=True, parallel=True)
|
|
834
|
+
def unfold9_order10(T, Tl, dims):
|
|
835
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 = dims
|
|
836
|
+
for i9 in prange(I9):
|
|
837
|
+
for i7 in range(I7):
|
|
838
|
+
for i6 in range(I6):
|
|
839
|
+
for i5 in range(I5):
|
|
840
|
+
for i4 in range(I4):
|
|
841
|
+
for i3 in range(I3):
|
|
842
|
+
for i2 in range(I2):
|
|
843
|
+
for i1 in range(I1):
|
|
844
|
+
for i0 in range(I0):
|
|
845
|
+
s = i9*I0*I1*I2*I3*I4*I5*I6*I7 + i7*I0*I1*I2*I3*I4*I5*I6 + i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
846
|
+
Tl[:,s] = T[i0, i1, i2, i3, i4, i5, i6, i7, :, i9]
|
|
847
|
+
return Tl
|
|
848
|
+
|
|
849
|
+
|
|
850
|
+
@njit(nogil=True, parallel=True)
|
|
851
|
+
def unfold10_order10(T, Tl, dims):
|
|
852
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 = dims
|
|
853
|
+
for i8 in prange(I8):
|
|
854
|
+
for i7 in range(I7):
|
|
855
|
+
for i6 in range(I6):
|
|
856
|
+
for i5 in range(I5):
|
|
857
|
+
for i4 in range(I4):
|
|
858
|
+
for i3 in range(I3):
|
|
859
|
+
for i2 in range(I2):
|
|
860
|
+
for i1 in range(I1):
|
|
861
|
+
for i0 in range(I0):
|
|
862
|
+
s = i8*I0*I1*I2*I3*I4*I5*I6*I7 + i7*I0*I1*I2*I3*I4*I5*I6 + i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
863
|
+
Tl[:,s] = T[i0, i1, i2, i3, i4, i5, i6, i7, i8, :]
|
|
864
|
+
return Tl
|
|
865
|
+
|
|
866
|
+
|
|
867
|
+
@njit(nogil=True, parallel=True)
|
|
868
|
+
def unfold1_order11(T, Tl, dims):
|
|
869
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10 = dims
|
|
870
|
+
for i10 in prange(I10):
|
|
871
|
+
for i9 in range(I9):
|
|
872
|
+
for i8 in range(I8):
|
|
873
|
+
for i7 in range(I7):
|
|
874
|
+
for i6 in range(I6):
|
|
875
|
+
for i5 in range(I5):
|
|
876
|
+
for i4 in range(I4):
|
|
877
|
+
for i3 in range(I3):
|
|
878
|
+
for i2 in range(I2):
|
|
879
|
+
for i1 in range(I1):
|
|
880
|
+
s = i10*I1*I2*I3*I4*I5*I6*I7*I8*I9 + i9*I1*I2*I3*I4*I5*I6*I7*I8 + i8*I1*I2*I3*I4*I5*I6*I7 + i7*I1*I2*I3*I4*I5*I6 + i6*I1*I2*I3*I4*I5 + i5*I1*I2*I3*I4 + i4*I1*I2*I3 + i3*I1*I2 + i2*I1 + i1
|
|
881
|
+
Tl[:,s] = T[:, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10]
|
|
882
|
+
return Tl
|
|
883
|
+
|
|
884
|
+
|
|
885
|
+
@njit(nogil=True, parallel=True)
|
|
886
|
+
def unfold2_order11(T, Tl, dims):
|
|
887
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10 = dims
|
|
888
|
+
for i10 in prange(I10):
|
|
889
|
+
for i9 in range(I9):
|
|
890
|
+
for i8 in range(I8):
|
|
891
|
+
for i7 in range(I7):
|
|
892
|
+
for i6 in range(I6):
|
|
893
|
+
for i5 in range(I5):
|
|
894
|
+
for i4 in range(I4):
|
|
895
|
+
for i3 in range(I3):
|
|
896
|
+
for i2 in range(I2):
|
|
897
|
+
for i0 in range(I0):
|
|
898
|
+
s = i10*I0*I2*I3*I4*I5*I6*I7*I8*I9 + i9*I0*I2*I3*I4*I5*I6*I7*I8 + i8*I0*I2*I3*I4*I5*I6*I7 + i7*I0*I2*I3*I4*I5*I6 + i6*I0*I2*I3*I4*I5 + i5*I0*I2*I3*I4 + i4*I0*I2*I3 + i3*I0*I2 + i2*I0 + i0
|
|
899
|
+
Tl[:,s] = T[i0, :, i2, i3, i4, i5, i6, i7, i8, i9, i10]
|
|
900
|
+
return Tl
|
|
901
|
+
|
|
902
|
+
|
|
903
|
+
@njit(nogil=True, parallel=True)
|
|
904
|
+
def unfold3_order11(T, Tl, dims):
|
|
905
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10 = dims
|
|
906
|
+
for i10 in prange(I10):
|
|
907
|
+
for i9 in range(I9):
|
|
908
|
+
for i8 in range(I8):
|
|
909
|
+
for i7 in range(I7):
|
|
910
|
+
for i6 in range(I6):
|
|
911
|
+
for i5 in range(I5):
|
|
912
|
+
for i4 in range(I4):
|
|
913
|
+
for i3 in range(I3):
|
|
914
|
+
for i1 in range(I1):
|
|
915
|
+
for i0 in range(I0):
|
|
916
|
+
s = i10*I0*I1*I3*I4*I5*I6*I7*I8*I9 + i9*I0*I1*I3*I4*I5*I6*I7*I8 + i8*I0*I1*I3*I4*I5*I6*I7 + i7*I0*I1*I3*I4*I5*I6 + i6*I0*I1*I3*I4*I5 + i5*I0*I1*I3*I4 + i4*I0*I1*I3 + i3*I0*I1 + i1*I0 + i0
|
|
917
|
+
Tl[:,s] = T[i0, i1, :, i3, i4, i5, i6, i7, i8, i9, i10]
|
|
918
|
+
return Tl
|
|
919
|
+
|
|
920
|
+
|
|
921
|
+
@njit(nogil=True, parallel=True)
|
|
922
|
+
def unfold4_order11(T, Tl, dims):
|
|
923
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10 = dims
|
|
924
|
+
for i10 in prange(I10):
|
|
925
|
+
for i9 in range(I9):
|
|
926
|
+
for i8 in range(I8):
|
|
927
|
+
for i7 in range(I7):
|
|
928
|
+
for i6 in range(I6):
|
|
929
|
+
for i5 in range(I5):
|
|
930
|
+
for i4 in range(I4):
|
|
931
|
+
for i2 in range(I2):
|
|
932
|
+
for i1 in range(I1):
|
|
933
|
+
for i0 in range(I0):
|
|
934
|
+
s = i10*I0*I1*I2*I4*I5*I6*I7*I8*I9 + i9*I0*I1*I2*I4*I5*I6*I7*I8 + i8*I0*I1*I2*I4*I5*I6*I7 + i7*I0*I1*I2*I4*I5*I6 + i6*I0*I1*I2*I4*I5 + i5*I0*I1*I2*I4 + i4*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
935
|
+
Tl[:,s] = T[i0, i1, i2, :, i4, i5, i6, i7, i8, i9, i10]
|
|
936
|
+
return Tl
|
|
937
|
+
|
|
938
|
+
|
|
939
|
+
@njit(nogil=True, parallel=True)
|
|
940
|
+
def unfold5_order11(T, Tl, dims):
|
|
941
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10 = dims
|
|
942
|
+
for i10 in prange(I10):
|
|
943
|
+
for i9 in range(I9):
|
|
944
|
+
for i8 in range(I8):
|
|
945
|
+
for i7 in range(I7):
|
|
946
|
+
for i6 in range(I6):
|
|
947
|
+
for i5 in range(I5):
|
|
948
|
+
for i3 in range(I3):
|
|
949
|
+
for i2 in range(I2):
|
|
950
|
+
for i1 in range(I1):
|
|
951
|
+
for i0 in range(I0):
|
|
952
|
+
s = i10*I0*I1*I2*I3*I5*I6*I7*I8*I9 + i9*I0*I1*I2*I3*I5*I6*I7*I8 + i8*I0*I1*I2*I3*I5*I6*I7 + i7*I0*I1*I2*I3*I5*I6 + i6*I0*I1*I2*I3*I5 + i5*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
953
|
+
Tl[:,s] = T[i0, i1, i2, i3, :, i5, i6, i7, i8, i9, i10]
|
|
954
|
+
return Tl
|
|
955
|
+
|
|
956
|
+
|
|
957
|
+
@njit(nogil=True, parallel=True)
|
|
958
|
+
def unfold6_order11(T, Tl, dims):
|
|
959
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10 = dims
|
|
960
|
+
for i10 in prange(I10):
|
|
961
|
+
for i9 in range(I9):
|
|
962
|
+
for i8 in range(I8):
|
|
963
|
+
for i7 in range(I7):
|
|
964
|
+
for i6 in range(I6):
|
|
965
|
+
for i4 in range(I4):
|
|
966
|
+
for i3 in range(I3):
|
|
967
|
+
for i2 in range(I2):
|
|
968
|
+
for i1 in range(I1):
|
|
969
|
+
for i0 in range(I0):
|
|
970
|
+
s = i10*I0*I1*I2*I3*I4*I6*I7*I8*I9 + i9*I0*I1*I2*I3*I4*I6*I7*I8 + i8*I0*I1*I2*I3*I4*I6*I7 + i7*I0*I1*I2*I3*I4*I6 + i6*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
971
|
+
Tl[:,s] = T[i0, i1, i2, i3, i4, :, i6, i7, i8, i9, i10]
|
|
972
|
+
return Tl
|
|
973
|
+
|
|
974
|
+
|
|
975
|
+
@njit(nogil=True, parallel=True)
|
|
976
|
+
def unfold7_order11(T, Tl, dims):
|
|
977
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10 = dims
|
|
978
|
+
for i10 in prange(I10):
|
|
979
|
+
for i9 in range(I9):
|
|
980
|
+
for i8 in range(I8):
|
|
981
|
+
for i7 in range(I7):
|
|
982
|
+
for i5 in range(I5):
|
|
983
|
+
for i4 in range(I4):
|
|
984
|
+
for i3 in range(I3):
|
|
985
|
+
for i2 in range(I2):
|
|
986
|
+
for i1 in range(I1):
|
|
987
|
+
for i0 in range(I0):
|
|
988
|
+
s = i10*I0*I1*I2*I3*I4*I5*I7*I8*I9 + i9*I0*I1*I2*I3*I4*I5*I7*I8 + i8*I0*I1*I2*I3*I4*I5*I7 + i7*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
989
|
+
Tl[:,s] = T[i0, i1, i2, i3, i4, i5, :, i7, i8, i9, i10]
|
|
990
|
+
return Tl
|
|
991
|
+
|
|
992
|
+
|
|
993
|
+
@njit(nogil=True, parallel=True)
|
|
994
|
+
def unfold8_order11(T, Tl, dims):
|
|
995
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10 = dims
|
|
996
|
+
for i10 in prange(I10):
|
|
997
|
+
for i9 in range(I9):
|
|
998
|
+
for i8 in range(I8):
|
|
999
|
+
for i6 in range(I6):
|
|
1000
|
+
for i5 in range(I5):
|
|
1001
|
+
for i4 in range(I4):
|
|
1002
|
+
for i3 in range(I3):
|
|
1003
|
+
for i2 in range(I2):
|
|
1004
|
+
for i1 in range(I1):
|
|
1005
|
+
for i0 in range(I0):
|
|
1006
|
+
s = i10*I0*I1*I2*I3*I4*I5*I6*I8*I9 + i9*I0*I1*I2*I3*I4*I5*I6*I8 + i8*I0*I1*I2*I3*I4*I5*I6 + i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1007
|
+
Tl[:,s] = T[i0, i1, i2, i3, i4, i5, i6, :, i8, i9, i10]
|
|
1008
|
+
return Tl
|
|
1009
|
+
|
|
1010
|
+
|
|
1011
|
+
@njit(nogil=True, parallel=True)
|
|
1012
|
+
def unfold9_order11(T, Tl, dims):
|
|
1013
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10 = dims
|
|
1014
|
+
for i10 in prange(I10):
|
|
1015
|
+
for i9 in range(I9):
|
|
1016
|
+
for i7 in range(I7):
|
|
1017
|
+
for i6 in range(I6):
|
|
1018
|
+
for i5 in range(I5):
|
|
1019
|
+
for i4 in range(I4):
|
|
1020
|
+
for i3 in range(I3):
|
|
1021
|
+
for i2 in range(I2):
|
|
1022
|
+
for i1 in range(I1):
|
|
1023
|
+
for i0 in range(I0):
|
|
1024
|
+
s = i10*I0*I1*I2*I3*I4*I5*I6*I7*I9 + i9*I0*I1*I2*I3*I4*I5*I6*I7 + i7*I0*I1*I2*I3*I4*I5*I6 + i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1025
|
+
Tl[:,s] = T[i0, i1, i2, i3, i4, i5, i6, i7, :, i9, i10]
|
|
1026
|
+
return Tl
|
|
1027
|
+
|
|
1028
|
+
|
|
1029
|
+
@njit(nogil=True, parallel=True)
|
|
1030
|
+
def unfold10_order11(T, Tl, dims):
|
|
1031
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10 = dims
|
|
1032
|
+
for i10 in prange(I10):
|
|
1033
|
+
for i8 in range(I8):
|
|
1034
|
+
for i7 in range(I7):
|
|
1035
|
+
for i6 in range(I6):
|
|
1036
|
+
for i5 in range(I5):
|
|
1037
|
+
for i4 in range(I4):
|
|
1038
|
+
for i3 in range(I3):
|
|
1039
|
+
for i2 in range(I2):
|
|
1040
|
+
for i1 in range(I1):
|
|
1041
|
+
for i0 in range(I0):
|
|
1042
|
+
s = i10*I0*I1*I2*I3*I4*I5*I6*I7*I8 + i8*I0*I1*I2*I3*I4*I5*I6*I7 + i7*I0*I1*I2*I3*I4*I5*I6 + i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1043
|
+
Tl[:,s] = T[i0, i1, i2, i3, i4, i5, i6, i7, i8, :, i10]
|
|
1044
|
+
return Tl
|
|
1045
|
+
|
|
1046
|
+
|
|
1047
|
+
@njit(nogil=True, parallel=True)
|
|
1048
|
+
def unfold11_order11(T, Tl, dims):
|
|
1049
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10 = dims
|
|
1050
|
+
for i9 in prange(I9):
|
|
1051
|
+
for i8 in range(I8):
|
|
1052
|
+
for i7 in range(I7):
|
|
1053
|
+
for i6 in range(I6):
|
|
1054
|
+
for i5 in range(I5):
|
|
1055
|
+
for i4 in range(I4):
|
|
1056
|
+
for i3 in range(I3):
|
|
1057
|
+
for i2 in range(I2):
|
|
1058
|
+
for i1 in range(I1):
|
|
1059
|
+
for i0 in range(I0):
|
|
1060
|
+
s = i9*I0*I1*I2*I3*I4*I5*I6*I7*I8 + i8*I0*I1*I2*I3*I4*I5*I6*I7 + i7*I0*I1*I2*I3*I4*I5*I6 + i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1061
|
+
Tl[:,s] = T[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, :]
|
|
1062
|
+
return Tl
|
|
1063
|
+
|
|
1064
|
+
|
|
1065
|
+
@njit(nogil=True, parallel=True)
|
|
1066
|
+
def unfold1_order12(T, Tl, dims):
|
|
1067
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11 = dims
|
|
1068
|
+
for i11 in prange(I11):
|
|
1069
|
+
for i10 in range(I10):
|
|
1070
|
+
for i9 in range(I9):
|
|
1071
|
+
for i8 in range(I8):
|
|
1072
|
+
for i7 in range(I7):
|
|
1073
|
+
for i6 in range(I6):
|
|
1074
|
+
for i5 in range(I5):
|
|
1075
|
+
for i4 in range(I4):
|
|
1076
|
+
for i3 in range(I3):
|
|
1077
|
+
for i2 in range(I2):
|
|
1078
|
+
for i1 in range(I1):
|
|
1079
|
+
s = i11*I1*I2*I3*I4*I5*I6*I7*I8*I9*I10 + i10*I1*I2*I3*I4*I5*I6*I7*I8*I9 + i9*I1*I2*I3*I4*I5*I6*I7*I8 + i8*I1*I2*I3*I4*I5*I6*I7 + i7*I1*I2*I3*I4*I5*I6 + i6*I1*I2*I3*I4*I5 + i5*I1*I2*I3*I4 + i4*I1*I2*I3 + i3*I1*I2 + i2*I1 + i1
|
|
1080
|
+
Tl[:,s] = T[:, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11]
|
|
1081
|
+
return Tl
|
|
1082
|
+
|
|
1083
|
+
|
|
1084
|
+
@njit(nogil=True, parallel=True)
|
|
1085
|
+
def unfold2_order12(T, Tl, dims):
|
|
1086
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11 = dims
|
|
1087
|
+
for i11 in prange(I11):
|
|
1088
|
+
for i10 in range(I10):
|
|
1089
|
+
for i9 in range(I9):
|
|
1090
|
+
for i8 in range(I8):
|
|
1091
|
+
for i7 in range(I7):
|
|
1092
|
+
for i6 in range(I6):
|
|
1093
|
+
for i5 in range(I5):
|
|
1094
|
+
for i4 in range(I4):
|
|
1095
|
+
for i3 in range(I3):
|
|
1096
|
+
for i2 in range(I2):
|
|
1097
|
+
for i0 in range(I0):
|
|
1098
|
+
s = i11*I0*I2*I3*I4*I5*I6*I7*I8*I9*I10 + i10*I0*I2*I3*I4*I5*I6*I7*I8*I9 + i9*I0*I2*I3*I4*I5*I6*I7*I8 + i8*I0*I2*I3*I4*I5*I6*I7 + i7*I0*I2*I3*I4*I5*I6 + i6*I0*I2*I3*I4*I5 + i5*I0*I2*I3*I4 + i4*I0*I2*I3 + i3*I0*I2 + i2*I0 + i0
|
|
1099
|
+
Tl[:,s] = T[i0, :, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11]
|
|
1100
|
+
return Tl
|
|
1101
|
+
|
|
1102
|
+
|
|
1103
|
+
@njit(nogil=True, parallel=True)
|
|
1104
|
+
def unfold3_order12(T, Tl, dims):
|
|
1105
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11 = dims
|
|
1106
|
+
for i11 in prange(I11):
|
|
1107
|
+
for i10 in range(I10):
|
|
1108
|
+
for i9 in range(I9):
|
|
1109
|
+
for i8 in range(I8):
|
|
1110
|
+
for i7 in range(I7):
|
|
1111
|
+
for i6 in range(I6):
|
|
1112
|
+
for i5 in range(I5):
|
|
1113
|
+
for i4 in range(I4):
|
|
1114
|
+
for i3 in range(I3):
|
|
1115
|
+
for i1 in range(I1):
|
|
1116
|
+
for i0 in range(I0):
|
|
1117
|
+
s = i11*I0*I1*I3*I4*I5*I6*I7*I8*I9*I10 + i10*I0*I1*I3*I4*I5*I6*I7*I8*I9 + i9*I0*I1*I3*I4*I5*I6*I7*I8 + i8*I0*I1*I3*I4*I5*I6*I7 + i7*I0*I1*I3*I4*I5*I6 + i6*I0*I1*I3*I4*I5 + i5*I0*I1*I3*I4 + i4*I0*I1*I3 + i3*I0*I1 + i1*I0 + i0
|
|
1118
|
+
Tl[:,s] = T[i0, i1, :, i3, i4, i5, i6, i7, i8, i9, i10, i11]
|
|
1119
|
+
return Tl
|
|
1120
|
+
|
|
1121
|
+
|
|
1122
|
+
@njit(nogil=True, parallel=True)
|
|
1123
|
+
def unfold4_order12(T, Tl, dims):
|
|
1124
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11 = dims
|
|
1125
|
+
for i11 in prange(I11):
|
|
1126
|
+
for i10 in range(I10):
|
|
1127
|
+
for i9 in range(I9):
|
|
1128
|
+
for i8 in range(I8):
|
|
1129
|
+
for i7 in range(I7):
|
|
1130
|
+
for i6 in range(I6):
|
|
1131
|
+
for i5 in range(I5):
|
|
1132
|
+
for i4 in range(I4):
|
|
1133
|
+
for i2 in range(I2):
|
|
1134
|
+
for i1 in range(I1):
|
|
1135
|
+
for i0 in range(I0):
|
|
1136
|
+
s = i11*I0*I1*I2*I4*I5*I6*I7*I8*I9*I10 + i10*I0*I1*I2*I4*I5*I6*I7*I8*I9 + i9*I0*I1*I2*I4*I5*I6*I7*I8 + i8*I0*I1*I2*I4*I5*I6*I7 + i7*I0*I1*I2*I4*I5*I6 + i6*I0*I1*I2*I4*I5 + i5*I0*I1*I2*I4 + i4*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1137
|
+
Tl[:,s] = T[i0, i1, i2, :, i4, i5, i6, i7, i8, i9, i10, i11]
|
|
1138
|
+
return Tl
|
|
1139
|
+
|
|
1140
|
+
|
|
1141
|
+
@njit(nogil=True, parallel=True)
|
|
1142
|
+
def unfold5_order12(T, Tl, dims):
|
|
1143
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11 = dims
|
|
1144
|
+
for i11 in prange(I11):
|
|
1145
|
+
for i10 in range(I10):
|
|
1146
|
+
for i9 in range(I9):
|
|
1147
|
+
for i8 in range(I8):
|
|
1148
|
+
for i7 in range(I7):
|
|
1149
|
+
for i6 in range(I6):
|
|
1150
|
+
for i5 in range(I5):
|
|
1151
|
+
for i3 in range(I3):
|
|
1152
|
+
for i2 in range(I2):
|
|
1153
|
+
for i1 in range(I1):
|
|
1154
|
+
for i0 in range(I0):
|
|
1155
|
+
s = i11*I0*I1*I2*I3*I5*I6*I7*I8*I9*I10 + i10*I0*I1*I2*I3*I5*I6*I7*I8*I9 + i9*I0*I1*I2*I3*I5*I6*I7*I8 + i8*I0*I1*I2*I3*I5*I6*I7 + i7*I0*I1*I2*I3*I5*I6 + i6*I0*I1*I2*I3*I5 + i5*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1156
|
+
Tl[:,s] = T[i0, i1, i2, i3, :, i5, i6, i7, i8, i9, i10, i11]
|
|
1157
|
+
return Tl
|
|
1158
|
+
|
|
1159
|
+
|
|
1160
|
+
@njit(nogil=True, parallel=True)
|
|
1161
|
+
def unfold6_order12(T, Tl, dims):
|
|
1162
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11 = dims
|
|
1163
|
+
for i11 in prange(I11):
|
|
1164
|
+
for i10 in range(I10):
|
|
1165
|
+
for i9 in range(I9):
|
|
1166
|
+
for i8 in range(I8):
|
|
1167
|
+
for i7 in range(I7):
|
|
1168
|
+
for i6 in range(I6):
|
|
1169
|
+
for i4 in range(I4):
|
|
1170
|
+
for i3 in range(I3):
|
|
1171
|
+
for i2 in range(I2):
|
|
1172
|
+
for i1 in range(I1):
|
|
1173
|
+
for i0 in range(I0):
|
|
1174
|
+
s = i11*I0*I1*I2*I3*I4*I6*I7*I8*I9*I10 + i10*I0*I1*I2*I3*I4*I6*I7*I8*I9 + i9*I0*I1*I2*I3*I4*I6*I7*I8 + i8*I0*I1*I2*I3*I4*I6*I7 + i7*I0*I1*I2*I3*I4*I6 + i6*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1175
|
+
Tl[:,s] = T[i0, i1, i2, i3, i4, :, i6, i7, i8, i9, i10, i11]
|
|
1176
|
+
return Tl
|
|
1177
|
+
|
|
1178
|
+
|
|
1179
|
+
@njit(nogil=True, parallel=True)
|
|
1180
|
+
def unfold7_order12(T, Tl, dims):
|
|
1181
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11 = dims
|
|
1182
|
+
for i11 in prange(I11):
|
|
1183
|
+
for i10 in range(I10):
|
|
1184
|
+
for i9 in range(I9):
|
|
1185
|
+
for i8 in range(I8):
|
|
1186
|
+
for i7 in range(I7):
|
|
1187
|
+
for i5 in range(I5):
|
|
1188
|
+
for i4 in range(I4):
|
|
1189
|
+
for i3 in range(I3):
|
|
1190
|
+
for i2 in range(I2):
|
|
1191
|
+
for i1 in range(I1):
|
|
1192
|
+
for i0 in range(I0):
|
|
1193
|
+
s = i11*I0*I1*I2*I3*I4*I5*I7*I8*I9*I10 + i10*I0*I1*I2*I3*I4*I5*I7*I8*I9 + i9*I0*I1*I2*I3*I4*I5*I7*I8 + i8*I0*I1*I2*I3*I4*I5*I7 + i7*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1194
|
+
Tl[:,s] = T[i0, i1, i2, i3, i4, i5, :, i7, i8, i9, i10, i11]
|
|
1195
|
+
return Tl
|
|
1196
|
+
|
|
1197
|
+
|
|
1198
|
+
@njit(nogil=True, parallel=True)
|
|
1199
|
+
def unfold8_order12(T, Tl, dims):
|
|
1200
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11 = dims
|
|
1201
|
+
for i11 in prange(I11):
|
|
1202
|
+
for i10 in range(I10):
|
|
1203
|
+
for i9 in range(I9):
|
|
1204
|
+
for i8 in range(I8):
|
|
1205
|
+
for i6 in range(I6):
|
|
1206
|
+
for i5 in range(I5):
|
|
1207
|
+
for i4 in range(I4):
|
|
1208
|
+
for i3 in range(I3):
|
|
1209
|
+
for i2 in range(I2):
|
|
1210
|
+
for i1 in range(I1):
|
|
1211
|
+
for i0 in range(I0):
|
|
1212
|
+
s = i11*I0*I1*I2*I3*I4*I5*I6*I8*I9*I10 + i10*I0*I1*I2*I3*I4*I5*I6*I8*I9 + i9*I0*I1*I2*I3*I4*I5*I6*I8 + i8*I0*I1*I2*I3*I4*I5*I6 + i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1213
|
+
Tl[:,s] = T[i0, i1, i2, i3, i4, i5, i6, :, i8, i9, i10, i11]
|
|
1214
|
+
return Tl
|
|
1215
|
+
|
|
1216
|
+
|
|
1217
|
+
@njit(nogil=True, parallel=True)
|
|
1218
|
+
def unfold9_order12(T, Tl, dims):
|
|
1219
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11 = dims
|
|
1220
|
+
for i11 in prange(I11):
|
|
1221
|
+
for i10 in range(I10):
|
|
1222
|
+
for i9 in range(I9):
|
|
1223
|
+
for i7 in range(I7):
|
|
1224
|
+
for i6 in range(I6):
|
|
1225
|
+
for i5 in range(I5):
|
|
1226
|
+
for i4 in range(I4):
|
|
1227
|
+
for i3 in range(I3):
|
|
1228
|
+
for i2 in range(I2):
|
|
1229
|
+
for i1 in range(I1):
|
|
1230
|
+
for i0 in range(I0):
|
|
1231
|
+
s = i11*I0*I1*I2*I3*I4*I5*I6*I7*I9*I10 + i10*I0*I1*I2*I3*I4*I5*I6*I7*I9 + i9*I0*I1*I2*I3*I4*I5*I6*I7 + i7*I0*I1*I2*I3*I4*I5*I6 + i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1232
|
+
Tl[:,s] = T[i0, i1, i2, i3, i4, i5, i6, i7, :, i9, i10, i11]
|
|
1233
|
+
return Tl
|
|
1234
|
+
|
|
1235
|
+
|
|
1236
|
+
@njit(nogil=True, parallel=True)
|
|
1237
|
+
def unfold10_order12(T, Tl, dims):
|
|
1238
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11 = dims
|
|
1239
|
+
for i11 in prange(I11):
|
|
1240
|
+
for i10 in range(I10):
|
|
1241
|
+
for i8 in range(I8):
|
|
1242
|
+
for i7 in range(I7):
|
|
1243
|
+
for i6 in range(I6):
|
|
1244
|
+
for i5 in range(I5):
|
|
1245
|
+
for i4 in range(I4):
|
|
1246
|
+
for i3 in range(I3):
|
|
1247
|
+
for i2 in range(I2):
|
|
1248
|
+
for i1 in range(I1):
|
|
1249
|
+
for i0 in range(I0):
|
|
1250
|
+
s = i11*I0*I1*I2*I3*I4*I5*I6*I7*I8*I10 + i10*I0*I1*I2*I3*I4*I5*I6*I7*I8 + i8*I0*I1*I2*I3*I4*I5*I6*I7 + i7*I0*I1*I2*I3*I4*I5*I6 + i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1251
|
+
Tl[:,s] = T[i0, i1, i2, i3, i4, i5, i6, i7, i8, :, i10, i11]
|
|
1252
|
+
return Tl
|
|
1253
|
+
|
|
1254
|
+
|
|
1255
|
+
@njit(nogil=True, parallel=True)
|
|
1256
|
+
def unfold11_order12(T, Tl, dims):
|
|
1257
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11 = dims
|
|
1258
|
+
for i11 in prange(I11):
|
|
1259
|
+
for i9 in range(I9):
|
|
1260
|
+
for i8 in range(I8):
|
|
1261
|
+
for i7 in range(I7):
|
|
1262
|
+
for i6 in range(I6):
|
|
1263
|
+
for i5 in range(I5):
|
|
1264
|
+
for i4 in range(I4):
|
|
1265
|
+
for i3 in range(I3):
|
|
1266
|
+
for i2 in range(I2):
|
|
1267
|
+
for i1 in range(I1):
|
|
1268
|
+
for i0 in range(I0):
|
|
1269
|
+
s = i11*I0*I1*I2*I3*I4*I5*I6*I7*I8*I9 + i9*I0*I1*I2*I3*I4*I5*I6*I7*I8 + i8*I0*I1*I2*I3*I4*I5*I6*I7 + i7*I0*I1*I2*I3*I4*I5*I6 + i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1270
|
+
Tl[:,s] = T[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, :, i11]
|
|
1271
|
+
return Tl
|
|
1272
|
+
|
|
1273
|
+
|
|
1274
|
+
@njit(nogil=True, parallel=True)
|
|
1275
|
+
def unfold12_order12(T, Tl, dims):
|
|
1276
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11 = dims
|
|
1277
|
+
for i10 in prange(I10):
|
|
1278
|
+
for i9 in range(I9):
|
|
1279
|
+
for i8 in range(I8):
|
|
1280
|
+
for i7 in range(I7):
|
|
1281
|
+
for i6 in range(I6):
|
|
1282
|
+
for i5 in range(I5):
|
|
1283
|
+
for i4 in range(I4):
|
|
1284
|
+
for i3 in range(I3):
|
|
1285
|
+
for i2 in range(I2):
|
|
1286
|
+
for i1 in range(I1):
|
|
1287
|
+
for i0 in range(I0):
|
|
1288
|
+
s = i10*I0*I1*I2*I3*I4*I5*I6*I7*I8*I9 + i9*I0*I1*I2*I3*I4*I5*I6*I7*I8 + i8*I0*I1*I2*I3*I4*I5*I6*I7 + i7*I0*I1*I2*I3*I4*I5*I6 + i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1289
|
+
Tl[:,s] = T[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, :]
|
|
1290
|
+
return Tl
|
|
1291
|
+
|
|
1292
|
+
|
|
1293
|
+
@njit(nogil=True, parallel=True)
|
|
1294
|
+
def foldback1_order3(T, Tl, dims):
|
|
1295
|
+
I0, I1, I2 = dims
|
|
1296
|
+
for i2 in prange(I2):
|
|
1297
|
+
for i1 in range(I1):
|
|
1298
|
+
s = i2*I1 + i1
|
|
1299
|
+
T[:, i1, i2] = Tl[:,s]
|
|
1300
|
+
return T
|
|
1301
|
+
|
|
1302
|
+
|
|
1303
|
+
@njit(nogil=True, parallel=True)
|
|
1304
|
+
def foldback2_order3(T, Tl, dims):
|
|
1305
|
+
I0, I1, I2 = dims
|
|
1306
|
+
for i2 in prange(I2):
|
|
1307
|
+
for i0 in range(I0):
|
|
1308
|
+
s = i2*I0 + i0
|
|
1309
|
+
T[i0, :, i2] = Tl[:,s]
|
|
1310
|
+
return T
|
|
1311
|
+
|
|
1312
|
+
|
|
1313
|
+
@njit(nogil=True, parallel=True)
|
|
1314
|
+
def foldback3_order3(T, Tl, dims):
|
|
1315
|
+
I0, I1, I2 = dims
|
|
1316
|
+
for i1 in prange(I1):
|
|
1317
|
+
for i0 in range(I0):
|
|
1318
|
+
s = i1*I0 + i0
|
|
1319
|
+
T[i0, i1, :] = Tl[:,s]
|
|
1320
|
+
return T
|
|
1321
|
+
|
|
1322
|
+
|
|
1323
|
+
@njit(nogil=True, parallel=True)
|
|
1324
|
+
def foldback1_order4(T, Tl, dims):
|
|
1325
|
+
I0, I1, I2, I3 = dims
|
|
1326
|
+
for i3 in prange(I3):
|
|
1327
|
+
for i2 in range(I2):
|
|
1328
|
+
for i1 in range(I1):
|
|
1329
|
+
s = i3*I1*I2 + i2*I1 + i1
|
|
1330
|
+
T[:, i1, i2, i3] = Tl[:,s]
|
|
1331
|
+
return T
|
|
1332
|
+
|
|
1333
|
+
|
|
1334
|
+
@njit(nogil=True, parallel=True)
|
|
1335
|
+
def foldback2_order4(T, Tl, dims):
|
|
1336
|
+
I0, I1, I2, I3 = dims
|
|
1337
|
+
for i3 in prange(I3):
|
|
1338
|
+
for i2 in range(I2):
|
|
1339
|
+
for i0 in range(I0):
|
|
1340
|
+
s = i3*I0*I2 + i2*I0 + i0
|
|
1341
|
+
T[i0, :, i2, i3] = Tl[:,s]
|
|
1342
|
+
return T
|
|
1343
|
+
|
|
1344
|
+
|
|
1345
|
+
@njit(nogil=True, parallel=True)
|
|
1346
|
+
def foldback3_order4(T, Tl, dims):
|
|
1347
|
+
I0, I1, I2, I3 = dims
|
|
1348
|
+
for i3 in prange(I3):
|
|
1349
|
+
for i1 in range(I1):
|
|
1350
|
+
for i0 in range(I0):
|
|
1351
|
+
s = i3*I0*I1 + i1*I0 + i0
|
|
1352
|
+
T[i0, i1, :, i3] = Tl[:,s]
|
|
1353
|
+
return T
|
|
1354
|
+
|
|
1355
|
+
|
|
1356
|
+
@njit(nogil=True, parallel=True)
|
|
1357
|
+
def foldback4_order4(T, Tl, dims):
|
|
1358
|
+
I0, I1, I2, I3 = dims
|
|
1359
|
+
for i2 in prange(I2):
|
|
1360
|
+
for i1 in range(I1):
|
|
1361
|
+
for i0 in range(I0):
|
|
1362
|
+
s = i2*I0*I1 + i1*I0 + i0
|
|
1363
|
+
T[i0, i1, i2, :] = Tl[:,s]
|
|
1364
|
+
return T
|
|
1365
|
+
|
|
1366
|
+
|
|
1367
|
+
@njit(nogil=True, parallel=True)
|
|
1368
|
+
def foldback1_order5(T, Tl, dims):
|
|
1369
|
+
I0, I1, I2, I3, I4 = dims
|
|
1370
|
+
for i4 in prange(I4):
|
|
1371
|
+
for i3 in range(I3):
|
|
1372
|
+
for i2 in range(I2):
|
|
1373
|
+
for i1 in range(I1):
|
|
1374
|
+
s = i4*I1*I2*I3 + i3*I1*I2 + i2*I1 + i1
|
|
1375
|
+
T[:, i1, i2, i3, i4] = Tl[:,s]
|
|
1376
|
+
return T
|
|
1377
|
+
|
|
1378
|
+
|
|
1379
|
+
@njit(nogil=True, parallel=True)
|
|
1380
|
+
def foldback2_order5(T, Tl, dims):
|
|
1381
|
+
I0, I1, I2, I3, I4 = dims
|
|
1382
|
+
for i4 in prange(I4):
|
|
1383
|
+
for i3 in range(I3):
|
|
1384
|
+
for i2 in range(I2):
|
|
1385
|
+
for i0 in range(I0):
|
|
1386
|
+
s = i4*I0*I2*I3 + i3*I0*I2 + i2*I0 + i0
|
|
1387
|
+
T[i0, :, i2, i3, i4] = Tl[:,s]
|
|
1388
|
+
return T
|
|
1389
|
+
|
|
1390
|
+
|
|
1391
|
+
@njit(nogil=True, parallel=True)
|
|
1392
|
+
def foldback3_order5(T, Tl, dims):
|
|
1393
|
+
I0, I1, I2, I3, I4 = dims
|
|
1394
|
+
for i4 in prange(I4):
|
|
1395
|
+
for i3 in range(I3):
|
|
1396
|
+
for i1 in range(I1):
|
|
1397
|
+
for i0 in range(I0):
|
|
1398
|
+
s = i4*I0*I1*I3 + i3*I0*I1 + i1*I0 + i0
|
|
1399
|
+
T[i0, i1, :, i3, i4] = Tl[:,s]
|
|
1400
|
+
return T
|
|
1401
|
+
|
|
1402
|
+
|
|
1403
|
+
@njit(nogil=True, parallel=True)
|
|
1404
|
+
def foldback4_order5(T, Tl, dims):
|
|
1405
|
+
I0, I1, I2, I3, I4 = dims
|
|
1406
|
+
for i4 in prange(I4):
|
|
1407
|
+
for i2 in range(I2):
|
|
1408
|
+
for i1 in range(I1):
|
|
1409
|
+
for i0 in range(I0):
|
|
1410
|
+
s = i4*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1411
|
+
T[i0, i1, i2, :, i4] = Tl[:,s]
|
|
1412
|
+
return T
|
|
1413
|
+
|
|
1414
|
+
|
|
1415
|
+
@njit(nogil=True, parallel=True)
|
|
1416
|
+
def foldback5_order5(T, Tl, dims):
|
|
1417
|
+
I0, I1, I2, I3, I4 = dims
|
|
1418
|
+
for i3 in prange(I3):
|
|
1419
|
+
for i2 in range(I2):
|
|
1420
|
+
for i1 in range(I1):
|
|
1421
|
+
for i0 in range(I0):
|
|
1422
|
+
s = i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1423
|
+
T[i0, i1, i2, i3, :] = Tl[:,s]
|
|
1424
|
+
return T
|
|
1425
|
+
|
|
1426
|
+
|
|
1427
|
+
@njit(nogil=True, parallel=True)
|
|
1428
|
+
def foldback1_order6(T, Tl, dims):
|
|
1429
|
+
I0, I1, I2, I3, I4, I5 = dims
|
|
1430
|
+
for i5 in prange(I5):
|
|
1431
|
+
for i4 in range(I4):
|
|
1432
|
+
for i3 in range(I3):
|
|
1433
|
+
for i2 in range(I2):
|
|
1434
|
+
for i1 in range(I1):
|
|
1435
|
+
s = i5*I1*I2*I3*I4 + i4*I1*I2*I3 + i3*I1*I2 + i2*I1 + i1
|
|
1436
|
+
T[:, i1, i2, i3, i4, i5] = Tl[:,s]
|
|
1437
|
+
return T
|
|
1438
|
+
|
|
1439
|
+
|
|
1440
|
+
@njit(nogil=True, parallel=True)
|
|
1441
|
+
def foldback2_order6(T, Tl, dims):
|
|
1442
|
+
I0, I1, I2, I3, I4, I5 = dims
|
|
1443
|
+
for i5 in prange(I5):
|
|
1444
|
+
for i4 in range(I4):
|
|
1445
|
+
for i3 in range(I3):
|
|
1446
|
+
for i2 in range(I2):
|
|
1447
|
+
for i0 in range(I0):
|
|
1448
|
+
s = i5*I0*I2*I3*I4 + i4*I0*I2*I3 + i3*I0*I2 + i2*I0 + i0
|
|
1449
|
+
T[i0, :, i2, i3, i4, i5] = Tl[:,s]
|
|
1450
|
+
return T
|
|
1451
|
+
|
|
1452
|
+
|
|
1453
|
+
@njit(nogil=True, parallel=True)
|
|
1454
|
+
def foldback3_order6(T, Tl, dims):
|
|
1455
|
+
I0, I1, I2, I3, I4, I5 = dims
|
|
1456
|
+
for i5 in prange(I5):
|
|
1457
|
+
for i4 in range(I4):
|
|
1458
|
+
for i3 in range(I3):
|
|
1459
|
+
for i1 in range(I1):
|
|
1460
|
+
for i0 in range(I0):
|
|
1461
|
+
s = i5*I0*I1*I3*I4 + i4*I0*I1*I3 + i3*I0*I1 + i1*I0 + i0
|
|
1462
|
+
T[i0, i1, :, i3, i4, i5] = Tl[:,s]
|
|
1463
|
+
return T
|
|
1464
|
+
|
|
1465
|
+
|
|
1466
|
+
@njit(nogil=True, parallel=True)
|
|
1467
|
+
def foldback4_order6(T, Tl, dims):
|
|
1468
|
+
I0, I1, I2, I3, I4, I5 = dims
|
|
1469
|
+
for i5 in prange(I5):
|
|
1470
|
+
for i4 in range(I4):
|
|
1471
|
+
for i2 in range(I2):
|
|
1472
|
+
for i1 in range(I1):
|
|
1473
|
+
for i0 in range(I0):
|
|
1474
|
+
s = i5*I0*I1*I2*I4 + i4*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1475
|
+
T[i0, i1, i2, :, i4, i5] = Tl[:,s]
|
|
1476
|
+
return T
|
|
1477
|
+
|
|
1478
|
+
|
|
1479
|
+
@njit(nogil=True, parallel=True)
|
|
1480
|
+
def foldback5_order6(T, Tl, dims):
|
|
1481
|
+
I0, I1, I2, I3, I4, I5 = dims
|
|
1482
|
+
for i5 in prange(I5):
|
|
1483
|
+
for i3 in range(I3):
|
|
1484
|
+
for i2 in range(I2):
|
|
1485
|
+
for i1 in range(I1):
|
|
1486
|
+
for i0 in range(I0):
|
|
1487
|
+
s = i5*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1488
|
+
T[i0, i1, i2, i3, :, i5] = Tl[:,s]
|
|
1489
|
+
return T
|
|
1490
|
+
|
|
1491
|
+
|
|
1492
|
+
@njit(nogil=True, parallel=True)
|
|
1493
|
+
def foldback6_order6(T, Tl, dims):
|
|
1494
|
+
I0, I1, I2, I3, I4, I5 = dims
|
|
1495
|
+
for i4 in prange(I4):
|
|
1496
|
+
for i3 in range(I3):
|
|
1497
|
+
for i2 in range(I2):
|
|
1498
|
+
for i1 in range(I1):
|
|
1499
|
+
for i0 in range(I0):
|
|
1500
|
+
s = i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1501
|
+
T[i0, i1, i2, i3, i4, :] = Tl[:,s]
|
|
1502
|
+
return T
|
|
1503
|
+
|
|
1504
|
+
|
|
1505
|
+
@njit(nogil=True, parallel=True)
|
|
1506
|
+
def foldback1_order7(T, Tl, dims):
|
|
1507
|
+
I0, I1, I2, I3, I4, I5, I6 = dims
|
|
1508
|
+
for i6 in prange(I6):
|
|
1509
|
+
for i5 in range(I5):
|
|
1510
|
+
for i4 in range(I4):
|
|
1511
|
+
for i3 in range(I3):
|
|
1512
|
+
for i2 in range(I2):
|
|
1513
|
+
for i1 in range(I1):
|
|
1514
|
+
s = i6*I1*I2*I3*I4*I5 + i5*I1*I2*I3*I4 + i4*I1*I2*I3 + i3*I1*I2 + i2*I1 + i1
|
|
1515
|
+
T[:, i1, i2, i3, i4, i5, i6] = Tl[:,s]
|
|
1516
|
+
return T
|
|
1517
|
+
|
|
1518
|
+
|
|
1519
|
+
@njit(nogil=True, parallel=True)
|
|
1520
|
+
def foldback2_order7(T, Tl, dims):
|
|
1521
|
+
I0, I1, I2, I3, I4, I5, I6 = dims
|
|
1522
|
+
for i6 in prange(I6):
|
|
1523
|
+
for i5 in range(I5):
|
|
1524
|
+
for i4 in range(I4):
|
|
1525
|
+
for i3 in range(I3):
|
|
1526
|
+
for i2 in range(I2):
|
|
1527
|
+
for i0 in range(I0):
|
|
1528
|
+
s = i6*I0*I2*I3*I4*I5 + i5*I0*I2*I3*I4 + i4*I0*I2*I3 + i3*I0*I2 + i2*I0 + i0
|
|
1529
|
+
T[i0, :, i2, i3, i4, i5, i6] = Tl[:,s]
|
|
1530
|
+
return T
|
|
1531
|
+
|
|
1532
|
+
|
|
1533
|
+
@njit(nogil=True, parallel=True)
|
|
1534
|
+
def foldback3_order7(T, Tl, dims):
|
|
1535
|
+
I0, I1, I2, I3, I4, I5, I6 = dims
|
|
1536
|
+
for i6 in prange(I6):
|
|
1537
|
+
for i5 in range(I5):
|
|
1538
|
+
for i4 in range(I4):
|
|
1539
|
+
for i3 in range(I3):
|
|
1540
|
+
for i1 in range(I1):
|
|
1541
|
+
for i0 in range(I0):
|
|
1542
|
+
s = i6*I0*I1*I3*I4*I5 + i5*I0*I1*I3*I4 + i4*I0*I1*I3 + i3*I0*I1 + i1*I0 + i0
|
|
1543
|
+
T[i0, i1, :, i3, i4, i5, i6] = Tl[:,s]
|
|
1544
|
+
return T
|
|
1545
|
+
|
|
1546
|
+
|
|
1547
|
+
@njit(nogil=True, parallel=True)
|
|
1548
|
+
def foldback4_order7(T, Tl, dims):
|
|
1549
|
+
I0, I1, I2, I3, I4, I5, I6 = dims
|
|
1550
|
+
for i6 in prange(I6):
|
|
1551
|
+
for i5 in range(I5):
|
|
1552
|
+
for i4 in range(I4):
|
|
1553
|
+
for i2 in range(I2):
|
|
1554
|
+
for i1 in range(I1):
|
|
1555
|
+
for i0 in range(I0):
|
|
1556
|
+
s = i6*I0*I1*I2*I4*I5 + i5*I0*I1*I2*I4 + i4*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1557
|
+
T[i0, i1, i2, :, i4, i5, i6] = Tl[:,s]
|
|
1558
|
+
return T
|
|
1559
|
+
|
|
1560
|
+
|
|
1561
|
+
@njit(nogil=True, parallel=True)
|
|
1562
|
+
def foldback5_order7(T, Tl, dims):
|
|
1563
|
+
I0, I1, I2, I3, I4, I5, I6 = dims
|
|
1564
|
+
for i6 in prange(I6):
|
|
1565
|
+
for i5 in range(I5):
|
|
1566
|
+
for i3 in range(I3):
|
|
1567
|
+
for i2 in range(I2):
|
|
1568
|
+
for i1 in range(I1):
|
|
1569
|
+
for i0 in range(I0):
|
|
1570
|
+
s = i6*I0*I1*I2*I3*I5 + i5*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1571
|
+
T[i0, i1, i2, i3, :, i5, i6] = Tl[:,s]
|
|
1572
|
+
return T
|
|
1573
|
+
|
|
1574
|
+
|
|
1575
|
+
@njit(nogil=True, parallel=True)
|
|
1576
|
+
def foldback6_order7(T, Tl, dims):
|
|
1577
|
+
I0, I1, I2, I3, I4, I5, I6 = dims
|
|
1578
|
+
for i6 in prange(I6):
|
|
1579
|
+
for i4 in range(I4):
|
|
1580
|
+
for i3 in range(I3):
|
|
1581
|
+
for i2 in range(I2):
|
|
1582
|
+
for i1 in range(I1):
|
|
1583
|
+
for i0 in range(I0):
|
|
1584
|
+
s = i6*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1585
|
+
T[i0, i1, i2, i3, i4, :, i6] = Tl[:,s]
|
|
1586
|
+
return T
|
|
1587
|
+
|
|
1588
|
+
|
|
1589
|
+
@njit(nogil=True, parallel=True)
|
|
1590
|
+
def foldback7_order7(T, Tl, dims):
|
|
1591
|
+
I0, I1, I2, I3, I4, I5, I6 = dims
|
|
1592
|
+
for i5 in prange(I5):
|
|
1593
|
+
for i4 in range(I4):
|
|
1594
|
+
for i3 in range(I3):
|
|
1595
|
+
for i2 in range(I2):
|
|
1596
|
+
for i1 in range(I1):
|
|
1597
|
+
for i0 in range(I0):
|
|
1598
|
+
s = i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1599
|
+
T[i0, i1, i2, i3, i4, i5, :] = Tl[:,s]
|
|
1600
|
+
return T
|
|
1601
|
+
|
|
1602
|
+
|
|
1603
|
+
@njit(nogil=True, parallel=True)
|
|
1604
|
+
def foldback1_order8(T, Tl, dims):
|
|
1605
|
+
I0, I1, I2, I3, I4, I5, I6, I7 = dims
|
|
1606
|
+
for i7 in prange(I7):
|
|
1607
|
+
for i6 in range(I6):
|
|
1608
|
+
for i5 in range(I5):
|
|
1609
|
+
for i4 in range(I4):
|
|
1610
|
+
for i3 in range(I3):
|
|
1611
|
+
for i2 in range(I2):
|
|
1612
|
+
for i1 in range(I1):
|
|
1613
|
+
s = i7*I1*I2*I3*I4*I5*I6 + i6*I1*I2*I3*I4*I5 + i5*I1*I2*I3*I4 + i4*I1*I2*I3 + i3*I1*I2 + i2*I1 + i1
|
|
1614
|
+
T[:, i1, i2, i3, i4, i5, i6, i7] = Tl[:,s]
|
|
1615
|
+
return T
|
|
1616
|
+
|
|
1617
|
+
|
|
1618
|
+
@njit(nogil=True, parallel=True)
|
|
1619
|
+
def foldback2_order8(T, Tl, dims):
|
|
1620
|
+
I0, I1, I2, I3, I4, I5, I6, I7 = dims
|
|
1621
|
+
for i7 in prange(I7):
|
|
1622
|
+
for i6 in range(I6):
|
|
1623
|
+
for i5 in range(I5):
|
|
1624
|
+
for i4 in range(I4):
|
|
1625
|
+
for i3 in range(I3):
|
|
1626
|
+
for i2 in range(I2):
|
|
1627
|
+
for i0 in range(I0):
|
|
1628
|
+
s = i7*I0*I2*I3*I4*I5*I6 + i6*I0*I2*I3*I4*I5 + i5*I0*I2*I3*I4 + i4*I0*I2*I3 + i3*I0*I2 + i2*I0 + i0
|
|
1629
|
+
T[i0, :, i2, i3, i4, i5, i6, i7] = Tl[:,s]
|
|
1630
|
+
return T
|
|
1631
|
+
|
|
1632
|
+
|
|
1633
|
+
@njit(nogil=True, parallel=True)
|
|
1634
|
+
def foldback3_order8(T, Tl, dims):
|
|
1635
|
+
I0, I1, I2, I3, I4, I5, I6, I7 = dims
|
|
1636
|
+
for i7 in prange(I7):
|
|
1637
|
+
for i6 in range(I6):
|
|
1638
|
+
for i5 in range(I5):
|
|
1639
|
+
for i4 in range(I4):
|
|
1640
|
+
for i3 in range(I3):
|
|
1641
|
+
for i1 in range(I1):
|
|
1642
|
+
for i0 in range(I0):
|
|
1643
|
+
s = i7*I0*I1*I3*I4*I5*I6 + i6*I0*I1*I3*I4*I5 + i5*I0*I1*I3*I4 + i4*I0*I1*I3 + i3*I0*I1 + i1*I0 + i0
|
|
1644
|
+
T[i0, i1, :, i3, i4, i5, i6, i7] = Tl[:,s]
|
|
1645
|
+
return T
|
|
1646
|
+
|
|
1647
|
+
|
|
1648
|
+
@njit(nogil=True, parallel=True)
|
|
1649
|
+
def foldback4_order8(T, Tl, dims):
|
|
1650
|
+
I0, I1, I2, I3, I4, I5, I6, I7 = dims
|
|
1651
|
+
for i7 in prange(I7):
|
|
1652
|
+
for i6 in range(I6):
|
|
1653
|
+
for i5 in range(I5):
|
|
1654
|
+
for i4 in range(I4):
|
|
1655
|
+
for i2 in range(I2):
|
|
1656
|
+
for i1 in range(I1):
|
|
1657
|
+
for i0 in range(I0):
|
|
1658
|
+
s = i7*I0*I1*I2*I4*I5*I6 + i6*I0*I1*I2*I4*I5 + i5*I0*I1*I2*I4 + i4*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1659
|
+
T[i0, i1, i2, :, i4, i5, i6, i7] = Tl[:,s]
|
|
1660
|
+
return T
|
|
1661
|
+
|
|
1662
|
+
|
|
1663
|
+
@njit(nogil=True, parallel=True)
|
|
1664
|
+
def foldback5_order8(T, Tl, dims):
|
|
1665
|
+
I0, I1, I2, I3, I4, I5, I6, I7 = dims
|
|
1666
|
+
for i7 in prange(I7):
|
|
1667
|
+
for i6 in range(I6):
|
|
1668
|
+
for i5 in range(I5):
|
|
1669
|
+
for i3 in range(I3):
|
|
1670
|
+
for i2 in range(I2):
|
|
1671
|
+
for i1 in range(I1):
|
|
1672
|
+
for i0 in range(I0):
|
|
1673
|
+
s = i7*I0*I1*I2*I3*I5*I6 + i6*I0*I1*I2*I3*I5 + i5*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1674
|
+
T[i0, i1, i2, i3, :, i5, i6, i7] = Tl[:,s]
|
|
1675
|
+
return T
|
|
1676
|
+
|
|
1677
|
+
|
|
1678
|
+
@njit(nogil=True, parallel=True)
|
|
1679
|
+
def foldback6_order8(T, Tl, dims):
|
|
1680
|
+
I0, I1, I2, I3, I4, I5, I6, I7 = dims
|
|
1681
|
+
for i7 in prange(I7):
|
|
1682
|
+
for i6 in range(I6):
|
|
1683
|
+
for i4 in range(I4):
|
|
1684
|
+
for i3 in range(I3):
|
|
1685
|
+
for i2 in range(I2):
|
|
1686
|
+
for i1 in range(I1):
|
|
1687
|
+
for i0 in range(I0):
|
|
1688
|
+
s = i7*I0*I1*I2*I3*I4*I6 + i6*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1689
|
+
T[i0, i1, i2, i3, i4, :, i6, i7] = Tl[:,s]
|
|
1690
|
+
return T
|
|
1691
|
+
|
|
1692
|
+
|
|
1693
|
+
@njit(nogil=True, parallel=True)
|
|
1694
|
+
def foldback7_order8(T, Tl, dims):
|
|
1695
|
+
I0, I1, I2, I3, I4, I5, I6, I7 = dims
|
|
1696
|
+
for i7 in prange(I7):
|
|
1697
|
+
for i5 in range(I5):
|
|
1698
|
+
for i4 in range(I4):
|
|
1699
|
+
for i3 in range(I3):
|
|
1700
|
+
for i2 in range(I2):
|
|
1701
|
+
for i1 in range(I1):
|
|
1702
|
+
for i0 in range(I0):
|
|
1703
|
+
s = i7*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1704
|
+
T[i0, i1, i2, i3, i4, i5, :, i7] = Tl[:,s]
|
|
1705
|
+
return T
|
|
1706
|
+
|
|
1707
|
+
|
|
1708
|
+
@njit(nogil=True, parallel=True)
|
|
1709
|
+
def foldback8_order8(T, Tl, dims):
|
|
1710
|
+
I0, I1, I2, I3, I4, I5, I6, I7 = dims
|
|
1711
|
+
for i6 in prange(I6):
|
|
1712
|
+
for i5 in range(I5):
|
|
1713
|
+
for i4 in range(I4):
|
|
1714
|
+
for i3 in range(I3):
|
|
1715
|
+
for i2 in range(I2):
|
|
1716
|
+
for i1 in range(I1):
|
|
1717
|
+
for i0 in range(I0):
|
|
1718
|
+
s = i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1719
|
+
T[i0, i1, i2, i3, i4, i5, i6, :] = Tl[:,s]
|
|
1720
|
+
return T
|
|
1721
|
+
|
|
1722
|
+
|
|
1723
|
+
@njit(nogil=True, parallel=True)
|
|
1724
|
+
def foldback1_order9(T, Tl, dims):
|
|
1725
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8 = dims
|
|
1726
|
+
for i8 in prange(I8):
|
|
1727
|
+
for i7 in range(I7):
|
|
1728
|
+
for i6 in range(I6):
|
|
1729
|
+
for i5 in range(I5):
|
|
1730
|
+
for i4 in range(I4):
|
|
1731
|
+
for i3 in range(I3):
|
|
1732
|
+
for i2 in range(I2):
|
|
1733
|
+
for i1 in range(I1):
|
|
1734
|
+
s = i8*I1*I2*I3*I4*I5*I6*I7 + i7*I1*I2*I3*I4*I5*I6 + i6*I1*I2*I3*I4*I5 + i5*I1*I2*I3*I4 + i4*I1*I2*I3 + i3*I1*I2 + i2*I1 + i1
|
|
1735
|
+
T[:, i1, i2, i3, i4, i5, i6, i7, i8] = Tl[:,s]
|
|
1736
|
+
return T
|
|
1737
|
+
|
|
1738
|
+
|
|
1739
|
+
@njit(nogil=True, parallel=True)
|
|
1740
|
+
def foldback2_order9(T, Tl, dims):
|
|
1741
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8 = dims
|
|
1742
|
+
for i8 in prange(I8):
|
|
1743
|
+
for i7 in range(I7):
|
|
1744
|
+
for i6 in range(I6):
|
|
1745
|
+
for i5 in range(I5):
|
|
1746
|
+
for i4 in range(I4):
|
|
1747
|
+
for i3 in range(I3):
|
|
1748
|
+
for i2 in range(I2):
|
|
1749
|
+
for i0 in range(I0):
|
|
1750
|
+
s = i8*I0*I2*I3*I4*I5*I6*I7 + i7*I0*I2*I3*I4*I5*I6 + i6*I0*I2*I3*I4*I5 + i5*I0*I2*I3*I4 + i4*I0*I2*I3 + i3*I0*I2 + i2*I0 + i0
|
|
1751
|
+
T[i0, :, i2, i3, i4, i5, i6, i7, i8] = Tl[:,s]
|
|
1752
|
+
return T
|
|
1753
|
+
|
|
1754
|
+
|
|
1755
|
+
@njit(nogil=True, parallel=True)
|
|
1756
|
+
def foldback3_order9(T, Tl, dims):
|
|
1757
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8 = dims
|
|
1758
|
+
for i8 in prange(I8):
|
|
1759
|
+
for i7 in range(I7):
|
|
1760
|
+
for i6 in range(I6):
|
|
1761
|
+
for i5 in range(I5):
|
|
1762
|
+
for i4 in range(I4):
|
|
1763
|
+
for i3 in range(I3):
|
|
1764
|
+
for i1 in range(I1):
|
|
1765
|
+
for i0 in range(I0):
|
|
1766
|
+
s = i8*I0*I1*I3*I4*I5*I6*I7 + i7*I0*I1*I3*I4*I5*I6 + i6*I0*I1*I3*I4*I5 + i5*I0*I1*I3*I4 + i4*I0*I1*I3 + i3*I0*I1 + i1*I0 + i0
|
|
1767
|
+
T[i0, i1, :, i3, i4, i5, i6, i7, i8] = Tl[:,s]
|
|
1768
|
+
return T
|
|
1769
|
+
|
|
1770
|
+
|
|
1771
|
+
@njit(nogil=True, parallel=True)
|
|
1772
|
+
def foldback4_order9(T, Tl, dims):
|
|
1773
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8 = dims
|
|
1774
|
+
for i8 in prange(I8):
|
|
1775
|
+
for i7 in range(I7):
|
|
1776
|
+
for i6 in range(I6):
|
|
1777
|
+
for i5 in range(I5):
|
|
1778
|
+
for i4 in range(I4):
|
|
1779
|
+
for i2 in range(I2):
|
|
1780
|
+
for i1 in range(I1):
|
|
1781
|
+
for i0 in range(I0):
|
|
1782
|
+
s = i8*I0*I1*I2*I4*I5*I6*I7 + i7*I0*I1*I2*I4*I5*I6 + i6*I0*I1*I2*I4*I5 + i5*I0*I1*I2*I4 + i4*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1783
|
+
T[i0, i1, i2, :, i4, i5, i6, i7, i8] = Tl[:,s]
|
|
1784
|
+
return T
|
|
1785
|
+
|
|
1786
|
+
|
|
1787
|
+
@njit(nogil=True, parallel=True)
|
|
1788
|
+
def foldback5_order9(T, Tl, dims):
|
|
1789
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8 = dims
|
|
1790
|
+
for i8 in prange(I8):
|
|
1791
|
+
for i7 in range(I7):
|
|
1792
|
+
for i6 in range(I6):
|
|
1793
|
+
for i5 in range(I5):
|
|
1794
|
+
for i3 in range(I3):
|
|
1795
|
+
for i2 in range(I2):
|
|
1796
|
+
for i1 in range(I1):
|
|
1797
|
+
for i0 in range(I0):
|
|
1798
|
+
s = i8*I0*I1*I2*I3*I5*I6*I7 + i7*I0*I1*I2*I3*I5*I6 + i6*I0*I1*I2*I3*I5 + i5*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1799
|
+
T[i0, i1, i2, i3, :, i5, i6, i7, i8] = Tl[:,s]
|
|
1800
|
+
return T
|
|
1801
|
+
|
|
1802
|
+
|
|
1803
|
+
@njit(nogil=True, parallel=True)
|
|
1804
|
+
def foldback6_order9(T, Tl, dims):
|
|
1805
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8 = dims
|
|
1806
|
+
for i8 in prange(I8):
|
|
1807
|
+
for i7 in range(I7):
|
|
1808
|
+
for i6 in range(I6):
|
|
1809
|
+
for i4 in range(I4):
|
|
1810
|
+
for i3 in range(I3):
|
|
1811
|
+
for i2 in range(I2):
|
|
1812
|
+
for i1 in range(I1):
|
|
1813
|
+
for i0 in range(I0):
|
|
1814
|
+
s = i8*I0*I1*I2*I3*I4*I6*I7 + i7*I0*I1*I2*I3*I4*I6 + i6*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1815
|
+
T[i0, i1, i2, i3, i4, :, i6, i7, i8] = Tl[:,s]
|
|
1816
|
+
return T
|
|
1817
|
+
|
|
1818
|
+
|
|
1819
|
+
@njit(nogil=True, parallel=True)
|
|
1820
|
+
def foldback7_order9(T, Tl, dims):
|
|
1821
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8 = dims
|
|
1822
|
+
for i8 in prange(I8):
|
|
1823
|
+
for i7 in range(I7):
|
|
1824
|
+
for i5 in range(I5):
|
|
1825
|
+
for i4 in range(I4):
|
|
1826
|
+
for i3 in range(I3):
|
|
1827
|
+
for i2 in range(I2):
|
|
1828
|
+
for i1 in range(I1):
|
|
1829
|
+
for i0 in range(I0):
|
|
1830
|
+
s = i8*I0*I1*I2*I3*I4*I5*I7 + i7*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1831
|
+
T[i0, i1, i2, i3, i4, i5, :, i7, i8] = Tl[:,s]
|
|
1832
|
+
return T
|
|
1833
|
+
|
|
1834
|
+
|
|
1835
|
+
@njit(nogil=True, parallel=True)
|
|
1836
|
+
def foldback8_order9(T, Tl, dims):
|
|
1837
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8 = dims
|
|
1838
|
+
for i8 in prange(I8):
|
|
1839
|
+
for i6 in range(I6):
|
|
1840
|
+
for i5 in range(I5):
|
|
1841
|
+
for i4 in range(I4):
|
|
1842
|
+
for i3 in range(I3):
|
|
1843
|
+
for i2 in range(I2):
|
|
1844
|
+
for i1 in range(I1):
|
|
1845
|
+
for i0 in range(I0):
|
|
1846
|
+
s = i8*I0*I1*I2*I3*I4*I5*I6 + i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1847
|
+
T[i0, i1, i2, i3, i4, i5, i6, :, i8] = Tl[:,s]
|
|
1848
|
+
return T
|
|
1849
|
+
|
|
1850
|
+
|
|
1851
|
+
@njit(nogil=True, parallel=True)
|
|
1852
|
+
def foldback9_order9(T, Tl, dims):
|
|
1853
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8 = dims
|
|
1854
|
+
for i7 in prange(I7):
|
|
1855
|
+
for i6 in range(I6):
|
|
1856
|
+
for i5 in range(I5):
|
|
1857
|
+
for i4 in range(I4):
|
|
1858
|
+
for i3 in range(I3):
|
|
1859
|
+
for i2 in range(I2):
|
|
1860
|
+
for i1 in range(I1):
|
|
1861
|
+
for i0 in range(I0):
|
|
1862
|
+
s = i7*I0*I1*I2*I3*I4*I5*I6 + i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1863
|
+
T[i0, i1, i2, i3, i4, i5, i6, i7, :] = Tl[:,s]
|
|
1864
|
+
return T
|
|
1865
|
+
|
|
1866
|
+
|
|
1867
|
+
@njit(nogil=True, parallel=True)
|
|
1868
|
+
def foldback1_order10(T, Tl, dims):
|
|
1869
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 = dims
|
|
1870
|
+
for i9 in prange(I9):
|
|
1871
|
+
for i8 in range(I8):
|
|
1872
|
+
for i7 in range(I7):
|
|
1873
|
+
for i6 in range(I6):
|
|
1874
|
+
for i5 in range(I5):
|
|
1875
|
+
for i4 in range(I4):
|
|
1876
|
+
for i3 in range(I3):
|
|
1877
|
+
for i2 in range(I2):
|
|
1878
|
+
for i1 in range(I1):
|
|
1879
|
+
s = i9*I1*I2*I3*I4*I5*I6*I7*I8 + i8*I1*I2*I3*I4*I5*I6*I7 + i7*I1*I2*I3*I4*I5*I6 + i6*I1*I2*I3*I4*I5 + i5*I1*I2*I3*I4 + i4*I1*I2*I3 + i3*I1*I2 + i2*I1 + i1
|
|
1880
|
+
T[:, i1, i2, i3, i4, i5, i6, i7, i8, i9] = Tl[:,s]
|
|
1881
|
+
return T
|
|
1882
|
+
|
|
1883
|
+
|
|
1884
|
+
@njit(nogil=True, parallel=True)
|
|
1885
|
+
def foldback2_order10(T, Tl, dims):
|
|
1886
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 = dims
|
|
1887
|
+
for i9 in prange(I9):
|
|
1888
|
+
for i8 in range(I8):
|
|
1889
|
+
for i7 in range(I7):
|
|
1890
|
+
for i6 in range(I6):
|
|
1891
|
+
for i5 in range(I5):
|
|
1892
|
+
for i4 in range(I4):
|
|
1893
|
+
for i3 in range(I3):
|
|
1894
|
+
for i2 in range(I2):
|
|
1895
|
+
for i0 in range(I0):
|
|
1896
|
+
s = i9*I0*I2*I3*I4*I5*I6*I7*I8 + i8*I0*I2*I3*I4*I5*I6*I7 + i7*I0*I2*I3*I4*I5*I6 + i6*I0*I2*I3*I4*I5 + i5*I0*I2*I3*I4 + i4*I0*I2*I3 + i3*I0*I2 + i2*I0 + i0
|
|
1897
|
+
T[i0, :, i2, i3, i4, i5, i6, i7, i8, i9] = Tl[:,s]
|
|
1898
|
+
return T
|
|
1899
|
+
|
|
1900
|
+
|
|
1901
|
+
@njit(nogil=True, parallel=True)
|
|
1902
|
+
def foldback3_order10(T, Tl, dims):
|
|
1903
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 = dims
|
|
1904
|
+
for i9 in prange(I9):
|
|
1905
|
+
for i8 in range(I8):
|
|
1906
|
+
for i7 in range(I7):
|
|
1907
|
+
for i6 in range(I6):
|
|
1908
|
+
for i5 in range(I5):
|
|
1909
|
+
for i4 in range(I4):
|
|
1910
|
+
for i3 in range(I3):
|
|
1911
|
+
for i1 in range(I1):
|
|
1912
|
+
for i0 in range(I0):
|
|
1913
|
+
s = i9*I0*I1*I3*I4*I5*I6*I7*I8 + i8*I0*I1*I3*I4*I5*I6*I7 + i7*I0*I1*I3*I4*I5*I6 + i6*I0*I1*I3*I4*I5 + i5*I0*I1*I3*I4 + i4*I0*I1*I3 + i3*I0*I1 + i1*I0 + i0
|
|
1914
|
+
T[i0, i1, :, i3, i4, i5, i6, i7, i8, i9] = Tl[:,s]
|
|
1915
|
+
return T
|
|
1916
|
+
|
|
1917
|
+
|
|
1918
|
+
@njit(nogil=True, parallel=True)
|
|
1919
|
+
def foldback4_order10(T, Tl, dims):
|
|
1920
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 = dims
|
|
1921
|
+
for i9 in prange(I9):
|
|
1922
|
+
for i8 in range(I8):
|
|
1923
|
+
for i7 in range(I7):
|
|
1924
|
+
for i6 in range(I6):
|
|
1925
|
+
for i5 in range(I5):
|
|
1926
|
+
for i4 in range(I4):
|
|
1927
|
+
for i2 in range(I2):
|
|
1928
|
+
for i1 in range(I1):
|
|
1929
|
+
for i0 in range(I0):
|
|
1930
|
+
s = i9*I0*I1*I2*I4*I5*I6*I7*I8 + i8*I0*I1*I2*I4*I5*I6*I7 + i7*I0*I1*I2*I4*I5*I6 + i6*I0*I1*I2*I4*I5 + i5*I0*I1*I2*I4 + i4*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1931
|
+
T[i0, i1, i2, :, i4, i5, i6, i7, i8, i9] = Tl[:,s]
|
|
1932
|
+
return T
|
|
1933
|
+
|
|
1934
|
+
|
|
1935
|
+
@njit(nogil=True, parallel=True)
|
|
1936
|
+
def foldback5_order10(T, Tl, dims):
|
|
1937
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 = dims
|
|
1938
|
+
for i9 in prange(I9):
|
|
1939
|
+
for i8 in range(I8):
|
|
1940
|
+
for i7 in range(I7):
|
|
1941
|
+
for i6 in range(I6):
|
|
1942
|
+
for i5 in range(I5):
|
|
1943
|
+
for i3 in range(I3):
|
|
1944
|
+
for i2 in range(I2):
|
|
1945
|
+
for i1 in range(I1):
|
|
1946
|
+
for i0 in range(I0):
|
|
1947
|
+
s = i9*I0*I1*I2*I3*I5*I6*I7*I8 + i8*I0*I1*I2*I3*I5*I6*I7 + i7*I0*I1*I2*I3*I5*I6 + i6*I0*I1*I2*I3*I5 + i5*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1948
|
+
T[i0, i1, i2, i3, :, i5, i6, i7, i8, i9] = Tl[:,s]
|
|
1949
|
+
return T
|
|
1950
|
+
|
|
1951
|
+
|
|
1952
|
+
@njit(nogil=True, parallel=True)
|
|
1953
|
+
def foldback6_order10(T, Tl, dims):
|
|
1954
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 = dims
|
|
1955
|
+
for i9 in prange(I9):
|
|
1956
|
+
for i8 in range(I8):
|
|
1957
|
+
for i7 in range(I7):
|
|
1958
|
+
for i6 in range(I6):
|
|
1959
|
+
for i4 in range(I4):
|
|
1960
|
+
for i3 in range(I3):
|
|
1961
|
+
for i2 in range(I2):
|
|
1962
|
+
for i1 in range(I1):
|
|
1963
|
+
for i0 in range(I0):
|
|
1964
|
+
s = i9*I0*I1*I2*I3*I4*I6*I7*I8 + i8*I0*I1*I2*I3*I4*I6*I7 + i7*I0*I1*I2*I3*I4*I6 + i6*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1965
|
+
T[i0, i1, i2, i3, i4, :, i6, i7, i8, i9] = Tl[:,s]
|
|
1966
|
+
return T
|
|
1967
|
+
|
|
1968
|
+
|
|
1969
|
+
@njit(nogil=True, parallel=True)
|
|
1970
|
+
def foldback7_order10(T, Tl, dims):
|
|
1971
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 = dims
|
|
1972
|
+
for i9 in prange(I9):
|
|
1973
|
+
for i8 in range(I8):
|
|
1974
|
+
for i7 in range(I7):
|
|
1975
|
+
for i5 in range(I5):
|
|
1976
|
+
for i4 in range(I4):
|
|
1977
|
+
for i3 in range(I3):
|
|
1978
|
+
for i2 in range(I2):
|
|
1979
|
+
for i1 in range(I1):
|
|
1980
|
+
for i0 in range(I0):
|
|
1981
|
+
s = i9*I0*I1*I2*I3*I4*I5*I7*I8 + i8*I0*I1*I2*I3*I4*I5*I7 + i7*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1982
|
+
T[i0, i1, i2, i3, i4, i5, :, i7, i8, i9] = Tl[:,s]
|
|
1983
|
+
return T
|
|
1984
|
+
|
|
1985
|
+
|
|
1986
|
+
@njit(nogil=True, parallel=True)
|
|
1987
|
+
def foldback8_order10(T, Tl, dims):
|
|
1988
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 = dims
|
|
1989
|
+
for i9 in prange(I9):
|
|
1990
|
+
for i8 in range(I8):
|
|
1991
|
+
for i6 in range(I6):
|
|
1992
|
+
for i5 in range(I5):
|
|
1993
|
+
for i4 in range(I4):
|
|
1994
|
+
for i3 in range(I3):
|
|
1995
|
+
for i2 in range(I2):
|
|
1996
|
+
for i1 in range(I1):
|
|
1997
|
+
for i0 in range(I0):
|
|
1998
|
+
s = i9*I0*I1*I2*I3*I4*I5*I6*I8 + i8*I0*I1*I2*I3*I4*I5*I6 + i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
1999
|
+
T[i0, i1, i2, i3, i4, i5, i6, :, i8, i9] = Tl[:,s]
|
|
2000
|
+
return T
|
|
2001
|
+
|
|
2002
|
+
|
|
2003
|
+
@njit(nogil=True, parallel=True)
|
|
2004
|
+
def foldback9_order10(T, Tl, dims):
|
|
2005
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 = dims
|
|
2006
|
+
for i9 in prange(I9):
|
|
2007
|
+
for i7 in range(I7):
|
|
2008
|
+
for i6 in range(I6):
|
|
2009
|
+
for i5 in range(I5):
|
|
2010
|
+
for i4 in range(I4):
|
|
2011
|
+
for i3 in range(I3):
|
|
2012
|
+
for i2 in range(I2):
|
|
2013
|
+
for i1 in range(I1):
|
|
2014
|
+
for i0 in range(I0):
|
|
2015
|
+
s = i9*I0*I1*I2*I3*I4*I5*I6*I7 + i7*I0*I1*I2*I3*I4*I5*I6 + i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
2016
|
+
T[i0, i1, i2, i3, i4, i5, i6, i7, :, i9] = Tl[:,s]
|
|
2017
|
+
return T
|
|
2018
|
+
|
|
2019
|
+
|
|
2020
|
+
@njit(nogil=True, parallel=True)
|
|
2021
|
+
def foldback10_order10(T, Tl, dims):
|
|
2022
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 = dims
|
|
2023
|
+
for i8 in prange(I8):
|
|
2024
|
+
for i7 in range(I7):
|
|
2025
|
+
for i6 in range(I6):
|
|
2026
|
+
for i5 in range(I5):
|
|
2027
|
+
for i4 in range(I4):
|
|
2028
|
+
for i3 in range(I3):
|
|
2029
|
+
for i2 in range(I2):
|
|
2030
|
+
for i1 in range(I1):
|
|
2031
|
+
for i0 in range(I0):
|
|
2032
|
+
s = i8*I0*I1*I2*I3*I4*I5*I6*I7 + i7*I0*I1*I2*I3*I4*I5*I6 + i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
2033
|
+
T[i0, i1, i2, i3, i4, i5, i6, i7, i8, :] = Tl[:,s]
|
|
2034
|
+
return T
|
|
2035
|
+
|
|
2036
|
+
|
|
2037
|
+
@njit(nogil=True, parallel=True)
|
|
2038
|
+
def foldback1_order11(T, Tl, dims):
|
|
2039
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10 = dims
|
|
2040
|
+
for i10 in prange(I10):
|
|
2041
|
+
for i9 in range(I9):
|
|
2042
|
+
for i8 in range(I8):
|
|
2043
|
+
for i7 in range(I7):
|
|
2044
|
+
for i6 in range(I6):
|
|
2045
|
+
for i5 in range(I5):
|
|
2046
|
+
for i4 in range(I4):
|
|
2047
|
+
for i3 in range(I3):
|
|
2048
|
+
for i2 in range(I2):
|
|
2049
|
+
for i1 in range(I1):
|
|
2050
|
+
s = i10*I1*I2*I3*I4*I5*I6*I7*I8*I9 + i9*I1*I2*I3*I4*I5*I6*I7*I8 + i8*I1*I2*I3*I4*I5*I6*I7 + i7*I1*I2*I3*I4*I5*I6 + i6*I1*I2*I3*I4*I5 + i5*I1*I2*I3*I4 + i4*I1*I2*I3 + i3*I1*I2 + i2*I1 + i1
|
|
2051
|
+
T[:, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10] = Tl[:,s]
|
|
2052
|
+
return T
|
|
2053
|
+
|
|
2054
|
+
|
|
2055
|
+
@njit(nogil=True, parallel=True)
|
|
2056
|
+
def foldback2_order11(T, Tl, dims):
|
|
2057
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10 = dims
|
|
2058
|
+
for i10 in prange(I10):
|
|
2059
|
+
for i9 in range(I9):
|
|
2060
|
+
for i8 in range(I8):
|
|
2061
|
+
for i7 in range(I7):
|
|
2062
|
+
for i6 in range(I6):
|
|
2063
|
+
for i5 in range(I5):
|
|
2064
|
+
for i4 in range(I4):
|
|
2065
|
+
for i3 in range(I3):
|
|
2066
|
+
for i2 in range(I2):
|
|
2067
|
+
for i0 in range(I0):
|
|
2068
|
+
s = i10*I0*I2*I3*I4*I5*I6*I7*I8*I9 + i9*I0*I2*I3*I4*I5*I6*I7*I8 + i8*I0*I2*I3*I4*I5*I6*I7 + i7*I0*I2*I3*I4*I5*I6 + i6*I0*I2*I3*I4*I5 + i5*I0*I2*I3*I4 + i4*I0*I2*I3 + i3*I0*I2 + i2*I0 + i0
|
|
2069
|
+
T[i0, :, i2, i3, i4, i5, i6, i7, i8, i9, i10] = Tl[:,s]
|
|
2070
|
+
return T
|
|
2071
|
+
|
|
2072
|
+
|
|
2073
|
+
@njit(nogil=True, parallel=True)
|
|
2074
|
+
def foldback3_order11(T, Tl, dims):
|
|
2075
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10 = dims
|
|
2076
|
+
for i10 in prange(I10):
|
|
2077
|
+
for i9 in range(I9):
|
|
2078
|
+
for i8 in range(I8):
|
|
2079
|
+
for i7 in range(I7):
|
|
2080
|
+
for i6 in range(I6):
|
|
2081
|
+
for i5 in range(I5):
|
|
2082
|
+
for i4 in range(I4):
|
|
2083
|
+
for i3 in range(I3):
|
|
2084
|
+
for i1 in range(I1):
|
|
2085
|
+
for i0 in range(I0):
|
|
2086
|
+
s = i10*I0*I1*I3*I4*I5*I6*I7*I8*I9 + i9*I0*I1*I3*I4*I5*I6*I7*I8 + i8*I0*I1*I3*I4*I5*I6*I7 + i7*I0*I1*I3*I4*I5*I6 + i6*I0*I1*I3*I4*I5 + i5*I0*I1*I3*I4 + i4*I0*I1*I3 + i3*I0*I1 + i1*I0 + i0
|
|
2087
|
+
T[i0, i1, :, i3, i4, i5, i6, i7, i8, i9, i10] = Tl[:,s]
|
|
2088
|
+
return T
|
|
2089
|
+
|
|
2090
|
+
|
|
2091
|
+
@njit(nogil=True, parallel=True)
|
|
2092
|
+
def foldback4_order11(T, Tl, dims):
|
|
2093
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10 = dims
|
|
2094
|
+
for i10 in prange(I10):
|
|
2095
|
+
for i9 in range(I9):
|
|
2096
|
+
for i8 in range(I8):
|
|
2097
|
+
for i7 in range(I7):
|
|
2098
|
+
for i6 in range(I6):
|
|
2099
|
+
for i5 in range(I5):
|
|
2100
|
+
for i4 in range(I4):
|
|
2101
|
+
for i2 in range(I2):
|
|
2102
|
+
for i1 in range(I1):
|
|
2103
|
+
for i0 in range(I0):
|
|
2104
|
+
s = i10*I0*I1*I2*I4*I5*I6*I7*I8*I9 + i9*I0*I1*I2*I4*I5*I6*I7*I8 + i8*I0*I1*I2*I4*I5*I6*I7 + i7*I0*I1*I2*I4*I5*I6 + i6*I0*I1*I2*I4*I5 + i5*I0*I1*I2*I4 + i4*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
2105
|
+
T[i0, i1, i2, :, i4, i5, i6, i7, i8, i9, i10] = Tl[:,s]
|
|
2106
|
+
return T
|
|
2107
|
+
|
|
2108
|
+
|
|
2109
|
+
@njit(nogil=True, parallel=True)
|
|
2110
|
+
def foldback5_order11(T, Tl, dims):
|
|
2111
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10 = dims
|
|
2112
|
+
for i10 in prange(I10):
|
|
2113
|
+
for i9 in range(I9):
|
|
2114
|
+
for i8 in range(I8):
|
|
2115
|
+
for i7 in range(I7):
|
|
2116
|
+
for i6 in range(I6):
|
|
2117
|
+
for i5 in range(I5):
|
|
2118
|
+
for i3 in range(I3):
|
|
2119
|
+
for i2 in range(I2):
|
|
2120
|
+
for i1 in range(I1):
|
|
2121
|
+
for i0 in range(I0):
|
|
2122
|
+
s = i10*I0*I1*I2*I3*I5*I6*I7*I8*I9 + i9*I0*I1*I2*I3*I5*I6*I7*I8 + i8*I0*I1*I2*I3*I5*I6*I7 + i7*I0*I1*I2*I3*I5*I6 + i6*I0*I1*I2*I3*I5 + i5*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
2123
|
+
T[i0, i1, i2, i3, :, i5, i6, i7, i8, i9, i10] = Tl[:,s]
|
|
2124
|
+
return T
|
|
2125
|
+
|
|
2126
|
+
|
|
2127
|
+
@njit(nogil=True, parallel=True)
|
|
2128
|
+
def foldback6_order11(T, Tl, dims):
|
|
2129
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10 = dims
|
|
2130
|
+
for i10 in prange(I10):
|
|
2131
|
+
for i9 in range(I9):
|
|
2132
|
+
for i8 in range(I8):
|
|
2133
|
+
for i7 in range(I7):
|
|
2134
|
+
for i6 in range(I6):
|
|
2135
|
+
for i4 in range(I4):
|
|
2136
|
+
for i3 in range(I3):
|
|
2137
|
+
for i2 in range(I2):
|
|
2138
|
+
for i1 in range(I1):
|
|
2139
|
+
for i0 in range(I0):
|
|
2140
|
+
s = i10*I0*I1*I2*I3*I4*I6*I7*I8*I9 + i9*I0*I1*I2*I3*I4*I6*I7*I8 + i8*I0*I1*I2*I3*I4*I6*I7 + i7*I0*I1*I2*I3*I4*I6 + i6*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
2141
|
+
T[i0, i1, i2, i3, i4, :, i6, i7, i8, i9, i10] = Tl[:,s]
|
|
2142
|
+
return T
|
|
2143
|
+
|
|
2144
|
+
|
|
2145
|
+
@njit(nogil=True, parallel=True)
|
|
2146
|
+
def foldback7_order11(T, Tl, dims):
|
|
2147
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10 = dims
|
|
2148
|
+
for i10 in prange(I10):
|
|
2149
|
+
for i9 in range(I9):
|
|
2150
|
+
for i8 in range(I8):
|
|
2151
|
+
for i7 in range(I7):
|
|
2152
|
+
for i5 in range(I5):
|
|
2153
|
+
for i4 in range(I4):
|
|
2154
|
+
for i3 in range(I3):
|
|
2155
|
+
for i2 in range(I2):
|
|
2156
|
+
for i1 in range(I1):
|
|
2157
|
+
for i0 in range(I0):
|
|
2158
|
+
s = i10*I0*I1*I2*I3*I4*I5*I7*I8*I9 + i9*I0*I1*I2*I3*I4*I5*I7*I8 + i8*I0*I1*I2*I3*I4*I5*I7 + i7*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
2159
|
+
T[i0, i1, i2, i3, i4, i5, :, i7, i8, i9, i10] = Tl[:,s]
|
|
2160
|
+
return T
|
|
2161
|
+
|
|
2162
|
+
|
|
2163
|
+
@njit(nogil=True, parallel=True)
|
|
2164
|
+
def foldback8_order11(T, Tl, dims):
|
|
2165
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10 = dims
|
|
2166
|
+
for i10 in prange(I10):
|
|
2167
|
+
for i9 in range(I9):
|
|
2168
|
+
for i8 in range(I8):
|
|
2169
|
+
for i6 in range(I6):
|
|
2170
|
+
for i5 in range(I5):
|
|
2171
|
+
for i4 in range(I4):
|
|
2172
|
+
for i3 in range(I3):
|
|
2173
|
+
for i2 in range(I2):
|
|
2174
|
+
for i1 in range(I1):
|
|
2175
|
+
for i0 in range(I0):
|
|
2176
|
+
s = i10*I0*I1*I2*I3*I4*I5*I6*I8*I9 + i9*I0*I1*I2*I3*I4*I5*I6*I8 + i8*I0*I1*I2*I3*I4*I5*I6 + i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
2177
|
+
T[i0, i1, i2, i3, i4, i5, i6, :, i8, i9, i10] = Tl[:,s]
|
|
2178
|
+
return T
|
|
2179
|
+
|
|
2180
|
+
|
|
2181
|
+
@njit(nogil=True, parallel=True)
|
|
2182
|
+
def foldback9_order11(T, Tl, dims):
|
|
2183
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10 = dims
|
|
2184
|
+
for i10 in prange(I10):
|
|
2185
|
+
for i9 in range(I9):
|
|
2186
|
+
for i7 in range(I7):
|
|
2187
|
+
for i6 in range(I6):
|
|
2188
|
+
for i5 in range(I5):
|
|
2189
|
+
for i4 in range(I4):
|
|
2190
|
+
for i3 in range(I3):
|
|
2191
|
+
for i2 in range(I2):
|
|
2192
|
+
for i1 in range(I1):
|
|
2193
|
+
for i0 in range(I0):
|
|
2194
|
+
s = i10*I0*I1*I2*I3*I4*I5*I6*I7*I9 + i9*I0*I1*I2*I3*I4*I5*I6*I7 + i7*I0*I1*I2*I3*I4*I5*I6 + i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
2195
|
+
T[i0, i1, i2, i3, i4, i5, i6, i7, :, i9, i10] = Tl[:,s]
|
|
2196
|
+
return T
|
|
2197
|
+
|
|
2198
|
+
|
|
2199
|
+
@njit(nogil=True, parallel=True)
|
|
2200
|
+
def foldback10_order11(T, Tl, dims):
|
|
2201
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10 = dims
|
|
2202
|
+
for i10 in prange(I10):
|
|
2203
|
+
for i8 in range(I8):
|
|
2204
|
+
for i7 in range(I7):
|
|
2205
|
+
for i6 in range(I6):
|
|
2206
|
+
for i5 in range(I5):
|
|
2207
|
+
for i4 in range(I4):
|
|
2208
|
+
for i3 in range(I3):
|
|
2209
|
+
for i2 in range(I2):
|
|
2210
|
+
for i1 in range(I1):
|
|
2211
|
+
for i0 in range(I0):
|
|
2212
|
+
s = i10*I0*I1*I2*I3*I4*I5*I6*I7*I8 + i8*I0*I1*I2*I3*I4*I5*I6*I7 + i7*I0*I1*I2*I3*I4*I5*I6 + i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
2213
|
+
T[i0, i1, i2, i3, i4, i5, i6, i7, i8, :, i10] = Tl[:,s]
|
|
2214
|
+
return T
|
|
2215
|
+
|
|
2216
|
+
|
|
2217
|
+
@njit(nogil=True, parallel=True)
|
|
2218
|
+
def foldback11_order11(T, Tl, dims):
|
|
2219
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10 = dims
|
|
2220
|
+
for i9 in prange(I9):
|
|
2221
|
+
for i8 in range(I8):
|
|
2222
|
+
for i7 in range(I7):
|
|
2223
|
+
for i6 in range(I6):
|
|
2224
|
+
for i5 in range(I5):
|
|
2225
|
+
for i4 in range(I4):
|
|
2226
|
+
for i3 in range(I3):
|
|
2227
|
+
for i2 in range(I2):
|
|
2228
|
+
for i1 in range(I1):
|
|
2229
|
+
for i0 in range(I0):
|
|
2230
|
+
s = i9*I0*I1*I2*I3*I4*I5*I6*I7*I8 + i8*I0*I1*I2*I3*I4*I5*I6*I7 + i7*I0*I1*I2*I3*I4*I5*I6 + i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
2231
|
+
T[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, :] = Tl[:,s]
|
|
2232
|
+
return T
|
|
2233
|
+
|
|
2234
|
+
|
|
2235
|
+
@njit(nogil=True, parallel=True)
|
|
2236
|
+
def foldback1_order12(T, Tl, dims):
|
|
2237
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11 = dims
|
|
2238
|
+
for i11 in prange(I11):
|
|
2239
|
+
for i10 in range(I10):
|
|
2240
|
+
for i9 in range(I9):
|
|
2241
|
+
for i8 in range(I8):
|
|
2242
|
+
for i7 in range(I7):
|
|
2243
|
+
for i6 in range(I6):
|
|
2244
|
+
for i5 in range(I5):
|
|
2245
|
+
for i4 in range(I4):
|
|
2246
|
+
for i3 in range(I3):
|
|
2247
|
+
for i2 in range(I2):
|
|
2248
|
+
for i1 in range(I1):
|
|
2249
|
+
s = i11*I1*I2*I3*I4*I5*I6*I7*I8*I9*I10 + i10*I1*I2*I3*I4*I5*I6*I7*I8*I9 + i9*I1*I2*I3*I4*I5*I6*I7*I8 + i8*I1*I2*I3*I4*I5*I6*I7 + i7*I1*I2*I3*I4*I5*I6 + i6*I1*I2*I3*I4*I5 + i5*I1*I2*I3*I4 + i4*I1*I2*I3 + i3*I1*I2 + i2*I1 + i1
|
|
2250
|
+
T[:, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11] = Tl[:,s]
|
|
2251
|
+
return T
|
|
2252
|
+
|
|
2253
|
+
|
|
2254
|
+
@njit(nogil=True, parallel=True)
|
|
2255
|
+
def foldback2_order12(T, Tl, dims):
|
|
2256
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11 = dims
|
|
2257
|
+
for i11 in prange(I11):
|
|
2258
|
+
for i10 in range(I10):
|
|
2259
|
+
for i9 in range(I9):
|
|
2260
|
+
for i8 in range(I8):
|
|
2261
|
+
for i7 in range(I7):
|
|
2262
|
+
for i6 in range(I6):
|
|
2263
|
+
for i5 in range(I5):
|
|
2264
|
+
for i4 in range(I4):
|
|
2265
|
+
for i3 in range(I3):
|
|
2266
|
+
for i2 in range(I2):
|
|
2267
|
+
for i0 in range(I0):
|
|
2268
|
+
s = i11*I0*I2*I3*I4*I5*I6*I7*I8*I9*I10 + i10*I0*I2*I3*I4*I5*I6*I7*I8*I9 + i9*I0*I2*I3*I4*I5*I6*I7*I8 + i8*I0*I2*I3*I4*I5*I6*I7 + i7*I0*I2*I3*I4*I5*I6 + i6*I0*I2*I3*I4*I5 + i5*I0*I2*I3*I4 + i4*I0*I2*I3 + i3*I0*I2 + i2*I0 + i0
|
|
2269
|
+
T[i0, :, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11] = Tl[:,s]
|
|
2270
|
+
return T
|
|
2271
|
+
|
|
2272
|
+
|
|
2273
|
+
@njit(nogil=True, parallel=True)
|
|
2274
|
+
def foldback3_order12(T, Tl, dims):
|
|
2275
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11 = dims
|
|
2276
|
+
for i11 in prange(I11):
|
|
2277
|
+
for i10 in range(I10):
|
|
2278
|
+
for i9 in range(I9):
|
|
2279
|
+
for i8 in range(I8):
|
|
2280
|
+
for i7 in range(I7):
|
|
2281
|
+
for i6 in range(I6):
|
|
2282
|
+
for i5 in range(I5):
|
|
2283
|
+
for i4 in range(I4):
|
|
2284
|
+
for i3 in range(I3):
|
|
2285
|
+
for i1 in range(I1):
|
|
2286
|
+
for i0 in range(I0):
|
|
2287
|
+
s = i11*I0*I1*I3*I4*I5*I6*I7*I8*I9*I10 + i10*I0*I1*I3*I4*I5*I6*I7*I8*I9 + i9*I0*I1*I3*I4*I5*I6*I7*I8 + i8*I0*I1*I3*I4*I5*I6*I7 + i7*I0*I1*I3*I4*I5*I6 + i6*I0*I1*I3*I4*I5 + i5*I0*I1*I3*I4 + i4*I0*I1*I3 + i3*I0*I1 + i1*I0 + i0
|
|
2288
|
+
T[i0, i1, :, i3, i4, i5, i6, i7, i8, i9, i10, i11] = Tl[:,s]
|
|
2289
|
+
return T
|
|
2290
|
+
|
|
2291
|
+
|
|
2292
|
+
@njit(nogil=True, parallel=True)
|
|
2293
|
+
def foldback4_order12(T, Tl, dims):
|
|
2294
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11 = dims
|
|
2295
|
+
for i11 in prange(I11):
|
|
2296
|
+
for i10 in range(I10):
|
|
2297
|
+
for i9 in range(I9):
|
|
2298
|
+
for i8 in range(I8):
|
|
2299
|
+
for i7 in range(I7):
|
|
2300
|
+
for i6 in range(I6):
|
|
2301
|
+
for i5 in range(I5):
|
|
2302
|
+
for i4 in range(I4):
|
|
2303
|
+
for i2 in range(I2):
|
|
2304
|
+
for i1 in range(I1):
|
|
2305
|
+
for i0 in range(I0):
|
|
2306
|
+
s = i11*I0*I1*I2*I4*I5*I6*I7*I8*I9*I10 + i10*I0*I1*I2*I4*I5*I6*I7*I8*I9 + i9*I0*I1*I2*I4*I5*I6*I7*I8 + i8*I0*I1*I2*I4*I5*I6*I7 + i7*I0*I1*I2*I4*I5*I6 + i6*I0*I1*I2*I4*I5 + i5*I0*I1*I2*I4 + i4*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
2307
|
+
T[i0, i1, i2, :, i4, i5, i6, i7, i8, i9, i10, i11] = Tl[:,s]
|
|
2308
|
+
return T
|
|
2309
|
+
|
|
2310
|
+
|
|
2311
|
+
@njit(nogil=True, parallel=True)
|
|
2312
|
+
def foldback5_order12(T, Tl, dims):
|
|
2313
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11 = dims
|
|
2314
|
+
for i11 in prange(I11):
|
|
2315
|
+
for i10 in range(I10):
|
|
2316
|
+
for i9 in range(I9):
|
|
2317
|
+
for i8 in range(I8):
|
|
2318
|
+
for i7 in range(I7):
|
|
2319
|
+
for i6 in range(I6):
|
|
2320
|
+
for i5 in range(I5):
|
|
2321
|
+
for i3 in range(I3):
|
|
2322
|
+
for i2 in range(I2):
|
|
2323
|
+
for i1 in range(I1):
|
|
2324
|
+
for i0 in range(I0):
|
|
2325
|
+
s = i11*I0*I1*I2*I3*I5*I6*I7*I8*I9*I10 + i10*I0*I1*I2*I3*I5*I6*I7*I8*I9 + i9*I0*I1*I2*I3*I5*I6*I7*I8 + i8*I0*I1*I2*I3*I5*I6*I7 + i7*I0*I1*I2*I3*I5*I6 + i6*I0*I1*I2*I3*I5 + i5*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
2326
|
+
T[i0, i1, i2, i3, :, i5, i6, i7, i8, i9, i10, i11] = Tl[:,s]
|
|
2327
|
+
return T
|
|
2328
|
+
|
|
2329
|
+
|
|
2330
|
+
@njit(nogil=True, parallel=True)
|
|
2331
|
+
def foldback6_order12(T, Tl, dims):
|
|
2332
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11 = dims
|
|
2333
|
+
for i11 in prange(I11):
|
|
2334
|
+
for i10 in range(I10):
|
|
2335
|
+
for i9 in range(I9):
|
|
2336
|
+
for i8 in range(I8):
|
|
2337
|
+
for i7 in range(I7):
|
|
2338
|
+
for i6 in range(I6):
|
|
2339
|
+
for i4 in range(I4):
|
|
2340
|
+
for i3 in range(I3):
|
|
2341
|
+
for i2 in range(I2):
|
|
2342
|
+
for i1 in range(I1):
|
|
2343
|
+
for i0 in range(I0):
|
|
2344
|
+
s = i11*I0*I1*I2*I3*I4*I6*I7*I8*I9*I10 + i10*I0*I1*I2*I3*I4*I6*I7*I8*I9 + i9*I0*I1*I2*I3*I4*I6*I7*I8 + i8*I0*I1*I2*I3*I4*I6*I7 + i7*I0*I1*I2*I3*I4*I6 + i6*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
2345
|
+
T[i0, i1, i2, i3, i4, :, i6, i7, i8, i9, i10, i11] = Tl[:,s]
|
|
2346
|
+
return T
|
|
2347
|
+
|
|
2348
|
+
|
|
2349
|
+
@njit(nogil=True, parallel=True)
|
|
2350
|
+
def foldback7_order12(T, Tl, dims):
|
|
2351
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11 = dims
|
|
2352
|
+
for i11 in prange(I11):
|
|
2353
|
+
for i10 in range(I10):
|
|
2354
|
+
for i9 in range(I9):
|
|
2355
|
+
for i8 in range(I8):
|
|
2356
|
+
for i7 in range(I7):
|
|
2357
|
+
for i5 in range(I5):
|
|
2358
|
+
for i4 in range(I4):
|
|
2359
|
+
for i3 in range(I3):
|
|
2360
|
+
for i2 in range(I2):
|
|
2361
|
+
for i1 in range(I1):
|
|
2362
|
+
for i0 in range(I0):
|
|
2363
|
+
s = i11*I0*I1*I2*I3*I4*I5*I7*I8*I9*I10 + i10*I0*I1*I2*I3*I4*I5*I7*I8*I9 + i9*I0*I1*I2*I3*I4*I5*I7*I8 + i8*I0*I1*I2*I3*I4*I5*I7 + i7*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
2364
|
+
T[i0, i1, i2, i3, i4, i5, :, i7, i8, i9, i10, i11] = Tl[:,s]
|
|
2365
|
+
return T
|
|
2366
|
+
|
|
2367
|
+
|
|
2368
|
+
@njit(nogil=True, parallel=True)
|
|
2369
|
+
def foldback8_order12(T, Tl, dims):
|
|
2370
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11 = dims
|
|
2371
|
+
for i11 in prange(I11):
|
|
2372
|
+
for i10 in range(I10):
|
|
2373
|
+
for i9 in range(I9):
|
|
2374
|
+
for i8 in range(I8):
|
|
2375
|
+
for i6 in range(I6):
|
|
2376
|
+
for i5 in range(I5):
|
|
2377
|
+
for i4 in range(I4):
|
|
2378
|
+
for i3 in range(I3):
|
|
2379
|
+
for i2 in range(I2):
|
|
2380
|
+
for i1 in range(I1):
|
|
2381
|
+
for i0 in range(I0):
|
|
2382
|
+
s = i11*I0*I1*I2*I3*I4*I5*I6*I8*I9*I10 + i10*I0*I1*I2*I3*I4*I5*I6*I8*I9 + i9*I0*I1*I2*I3*I4*I5*I6*I8 + i8*I0*I1*I2*I3*I4*I5*I6 + i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
2383
|
+
T[i0, i1, i2, i3, i4, i5, i6, :, i8, i9, i10, i11] = Tl[:,s]
|
|
2384
|
+
return T
|
|
2385
|
+
|
|
2386
|
+
|
|
2387
|
+
@njit(nogil=True, parallel=True)
|
|
2388
|
+
def foldback9_order12(T, Tl, dims):
|
|
2389
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11 = dims
|
|
2390
|
+
for i11 in prange(I11):
|
|
2391
|
+
for i10 in range(I10):
|
|
2392
|
+
for i9 in range(I9):
|
|
2393
|
+
for i7 in range(I7):
|
|
2394
|
+
for i6 in range(I6):
|
|
2395
|
+
for i5 in range(I5):
|
|
2396
|
+
for i4 in range(I4):
|
|
2397
|
+
for i3 in range(I3):
|
|
2398
|
+
for i2 in range(I2):
|
|
2399
|
+
for i1 in range(I1):
|
|
2400
|
+
for i0 in range(I0):
|
|
2401
|
+
s = i11*I0*I1*I2*I3*I4*I5*I6*I7*I9*I10 + i10*I0*I1*I2*I3*I4*I5*I6*I7*I9 + i9*I0*I1*I2*I3*I4*I5*I6*I7 + i7*I0*I1*I2*I3*I4*I5*I6 + i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
2402
|
+
T[i0, i1, i2, i3, i4, i5, i6, i7, :, i9, i10, i11] = Tl[:,s]
|
|
2403
|
+
return T
|
|
2404
|
+
|
|
2405
|
+
|
|
2406
|
+
@njit(nogil=True, parallel=True)
|
|
2407
|
+
def foldback10_order12(T, Tl, dims):
|
|
2408
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11 = dims
|
|
2409
|
+
for i11 in prange(I11):
|
|
2410
|
+
for i10 in range(I10):
|
|
2411
|
+
for i8 in range(I8):
|
|
2412
|
+
for i7 in range(I7):
|
|
2413
|
+
for i6 in range(I6):
|
|
2414
|
+
for i5 in range(I5):
|
|
2415
|
+
for i4 in range(I4):
|
|
2416
|
+
for i3 in range(I3):
|
|
2417
|
+
for i2 in range(I2):
|
|
2418
|
+
for i1 in range(I1):
|
|
2419
|
+
for i0 in range(I0):
|
|
2420
|
+
s = i11*I0*I1*I2*I3*I4*I5*I6*I7*I8*I10 + i10*I0*I1*I2*I3*I4*I5*I6*I7*I8 + i8*I0*I1*I2*I3*I4*I5*I6*I7 + i7*I0*I1*I2*I3*I4*I5*I6 + i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
2421
|
+
T[i0, i1, i2, i3, i4, i5, i6, i7, i8, :, i10, i11] = Tl[:,s]
|
|
2422
|
+
return T
|
|
2423
|
+
|
|
2424
|
+
|
|
2425
|
+
@njit(nogil=True, parallel=True)
|
|
2426
|
+
def foldback11_order12(T, Tl, dims):
|
|
2427
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11 = dims
|
|
2428
|
+
for i11 in prange(I11):
|
|
2429
|
+
for i9 in range(I9):
|
|
2430
|
+
for i8 in range(I8):
|
|
2431
|
+
for i7 in range(I7):
|
|
2432
|
+
for i6 in range(I6):
|
|
2433
|
+
for i5 in range(I5):
|
|
2434
|
+
for i4 in range(I4):
|
|
2435
|
+
for i3 in range(I3):
|
|
2436
|
+
for i2 in range(I2):
|
|
2437
|
+
for i1 in range(I1):
|
|
2438
|
+
for i0 in range(I0):
|
|
2439
|
+
s = i11*I0*I1*I2*I3*I4*I5*I6*I7*I8*I9 + i9*I0*I1*I2*I3*I4*I5*I6*I7*I8 + i8*I0*I1*I2*I3*I4*I5*I6*I7 + i7*I0*I1*I2*I3*I4*I5*I6 + i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
2440
|
+
T[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, :, i11] = Tl[:,s]
|
|
2441
|
+
return T
|
|
2442
|
+
|
|
2443
|
+
|
|
2444
|
+
@njit(nogil=True, parallel=True)
|
|
2445
|
+
def foldback12_order12(T, Tl, dims):
|
|
2446
|
+
I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11 = dims
|
|
2447
|
+
for i10 in prange(I10):
|
|
2448
|
+
for i9 in range(I9):
|
|
2449
|
+
for i8 in range(I8):
|
|
2450
|
+
for i7 in range(I7):
|
|
2451
|
+
for i6 in range(I6):
|
|
2452
|
+
for i5 in range(I5):
|
|
2453
|
+
for i4 in range(I4):
|
|
2454
|
+
for i3 in range(I3):
|
|
2455
|
+
for i2 in range(I2):
|
|
2456
|
+
for i1 in range(I1):
|
|
2457
|
+
for i0 in range(I0):
|
|
2458
|
+
s = i10*I0*I1*I2*I3*I4*I5*I6*I7*I8*I9 + i9*I0*I1*I2*I3*I4*I5*I6*I7*I8 + i8*I0*I1*I2*I3*I4*I5*I6*I7 + i7*I0*I1*I2*I3*I4*I5*I6 + i6*I0*I1*I2*I3*I4*I5 + i5*I0*I1*I2*I3*I4 + i4*I0*I1*I2*I3 + i3*I0*I1*I2 + i2*I0*I1 + i1*I0 + i0
|
|
2459
|
+
T[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, :] = Tl[:,s]
|
|
2460
|
+
return T
|
|
2461
|
+
|
|
2462
|
+
|
|
2463
|
+
@njit(nogil=True, parallel=True)
|
|
2464
|
+
def tt_error_order3(T, G0, G1, G2, dims, L):
|
|
2465
|
+
a, b, c = dims
|
|
2466
|
+
T_approx = empty(dims, dtype=float64)
|
|
2467
|
+
|
|
2468
|
+
for i0 in prange(a):
|
|
2469
|
+
for i1 in range(b):
|
|
2470
|
+
for i2 in range(c):
|
|
2471
|
+
A = G0[i0, :]
|
|
2472
|
+
B = dot(A, G1[:, i1, :])
|
|
2473
|
+
T_approx[i0, i1, i2] = dot(B, G2[:, i2])
|
|
2474
|
+
|
|
2475
|
+
return T_approx
|
|
2476
|
+
|
|
2477
|
+
|
|
2478
|
+
@njit(nogil=True, parallel=True)
|
|
2479
|
+
def tt_error_order4(T, G0, G1, G2, G3, dims, L):
|
|
2480
|
+
a, b, c, d = dims
|
|
2481
|
+
T_approx = empty(dims, dtype=float64)
|
|
2482
|
+
|
|
2483
|
+
for i0 in prange(a):
|
|
2484
|
+
for i1 in range(b):
|
|
2485
|
+
for i2 in range(c):
|
|
2486
|
+
for i3 in range(d):
|
|
2487
|
+
A = G0[i0,:]
|
|
2488
|
+
B = dot(A, G1[:,i1,:])
|
|
2489
|
+
C = dot(B, G2[:,i2,:])
|
|
2490
|
+
T_approx[i0,i1,i2,i3] = dot(C, G3[:,i3])
|
|
2491
|
+
|
|
2492
|
+
return T_approx
|
|
2493
|
+
|
|
2494
|
+
|
|
2495
|
+
@njit(nogil=True, parallel=True)
|
|
2496
|
+
def tt_error_order5(T, G0, G1, G2, G3, G4, dims, L):
|
|
2497
|
+
a, b, c, d, e = dims
|
|
2498
|
+
T_approx = empty(dims, dtype=float64)
|
|
2499
|
+
|
|
2500
|
+
for i0 in prange(a):
|
|
2501
|
+
for i1 in range(b):
|
|
2502
|
+
for i2 in range(c):
|
|
2503
|
+
for i3 in range(d):
|
|
2504
|
+
for i4 in range(e):
|
|
2505
|
+
A = G0[i0,:]
|
|
2506
|
+
B = dot(A, G1[:,i1,:])
|
|
2507
|
+
C = dot(B, G2[:,i2,:])
|
|
2508
|
+
D = dot(C, G3[:,i3,:])
|
|
2509
|
+
T_approx[i0,i1,i2,i3,i4] = dot(D, G4[:,i4])
|
|
2510
|
+
|
|
2511
|
+
return T_approx
|
|
2512
|
+
|
|
2513
|
+
|
|
2514
|
+
@njit(nogil=True, parallel=True)
|
|
2515
|
+
def tt_error_order6(T, G0, G1, G2, G3, G4, G5, dims, L):
|
|
2516
|
+
a, b, c, d, e, f = dims
|
|
2517
|
+
T_approx = empty(dims, dtype=float64)
|
|
2518
|
+
|
|
2519
|
+
for i0 in prange(a):
|
|
2520
|
+
for i1 in range(b):
|
|
2521
|
+
for i2 in range(c):
|
|
2522
|
+
for i3 in range(d):
|
|
2523
|
+
for i4 in range(e):
|
|
2524
|
+
for i5 in range(f):
|
|
2525
|
+
A = G0[i0,:]
|
|
2526
|
+
B = dot(A, G1[:,i1,:])
|
|
2527
|
+
C = dot(B, G2[:,i2,:])
|
|
2528
|
+
D = dot(C, G3[:,i3,:])
|
|
2529
|
+
E = dot(D, G4[:,i4,:])
|
|
2530
|
+
T_approx[i0,i1,i2,i3,i4,i5] = dot(E, G5[:,i5])
|
|
2531
|
+
|
|
2532
|
+
return T_approx
|
|
2533
|
+
|
|
2534
|
+
|
|
2535
|
+
@njit(nogil=True, parallel=True)
|
|
2536
|
+
def tt_error_order7(T, G0, G1, G2, G3, G4, G5, G6, dims, L):
|
|
2537
|
+
a, b, c, d, e, f, g = dims
|
|
2538
|
+
T_approx = empty(dims, dtype=float64)
|
|
2539
|
+
|
|
2540
|
+
for i0 in prange(a):
|
|
2541
|
+
for i1 in range(b):
|
|
2542
|
+
for i2 in range(c):
|
|
2543
|
+
for i3 in range(d):
|
|
2544
|
+
for i4 in range(e):
|
|
2545
|
+
for i5 in range(f):
|
|
2546
|
+
for i6 in range(g):
|
|
2547
|
+
A = G0[i0,:]
|
|
2548
|
+
B = dot(A, G1[:,i1,:])
|
|
2549
|
+
C = dot(B, G2[:,i2,:])
|
|
2550
|
+
D = dot(C, G3[:,i3,:])
|
|
2551
|
+
E = dot(D, G4[:,i4,:])
|
|
2552
|
+
F = dot(E, G5[:,i5,:])
|
|
2553
|
+
T_approx[i0,i1,i2,i3,i4,i5,i6] = dot(F, G6[:,i6])
|
|
2554
|
+
|
|
2555
|
+
return T_approx
|
|
2556
|
+
|
|
2557
|
+
|
|
2558
|
+
@njit(nogil=True, parallel=True)
|
|
2559
|
+
def tt_error_order8(T, G0, G1, G2, G3, G4, G5, G6, G7, dims, L):
|
|
2560
|
+
a, b, c, d, e, f, g, h = dims
|
|
2561
|
+
T_approx = empty(dims, dtype=float64)
|
|
2562
|
+
|
|
2563
|
+
for i0 in prange(a):
|
|
2564
|
+
for i1 in range(b):
|
|
2565
|
+
for i2 in range(c):
|
|
2566
|
+
for i3 in range(d):
|
|
2567
|
+
for i4 in range(e):
|
|
2568
|
+
for i5 in range(f):
|
|
2569
|
+
for i6 in range(g):
|
|
2570
|
+
for i7 in range(h):
|
|
2571
|
+
A = G0[i0,:]
|
|
2572
|
+
B = dot(A, G1[:,i1,:])
|
|
2573
|
+
C = dot(B, G2[:,i2,:])
|
|
2574
|
+
D = dot(C, G3[:,i3,:])
|
|
2575
|
+
E = dot(D, G4[:,i4,:])
|
|
2576
|
+
F = dot(E, G5[:,i5,:])
|
|
2577
|
+
G = dot(F, G6[:,i6,:])
|
|
2578
|
+
T_approx[i0,i1,i2,i3,i4,i5,i6,i7] = dot(G, G7[:,i7])
|
|
2579
|
+
|
|
2580
|
+
return T_approx
|
|
2581
|
+
|
|
2582
|
+
|
|
2583
|
+
@njit(nogil=True, parallel=True)
|
|
2584
|
+
def tt_error_order9(T, G0, G1, G2, G3, G4, G5, G6, G7, G8, dims, L):
|
|
2585
|
+
a, b, c, d, e, f, g, h, i = dims
|
|
2586
|
+
T_approx = empty(dims, dtype=float64)
|
|
2587
|
+
|
|
2588
|
+
for i0 in prange(a):
|
|
2589
|
+
for i1 in range(b):
|
|
2590
|
+
for i2 in range(c):
|
|
2591
|
+
for i3 in range(d):
|
|
2592
|
+
for i4 in range(e):
|
|
2593
|
+
for i5 in range(f):
|
|
2594
|
+
for i6 in range(g):
|
|
2595
|
+
for i7 in range(h):
|
|
2596
|
+
for i8 in range(i):
|
|
2597
|
+
A = G0[i0,:]
|
|
2598
|
+
B = dot(A, G1[:,i1,:])
|
|
2599
|
+
C = dot(B, G2[:,i2,:])
|
|
2600
|
+
D = dot(C, G3[:,i3,:])
|
|
2601
|
+
E = dot(D, G4[:,i4,:])
|
|
2602
|
+
F = dot(E, G5[:,i5,:])
|
|
2603
|
+
G = dot(F, G6[:,i6,:])
|
|
2604
|
+
H = dot(G, G7[:,i7,:])
|
|
2605
|
+
T_approx[i0,i1,i2,i3,i4,i5,i6,i7,i8] = dot(H, G8[:,i8])
|
|
2606
|
+
|
|
2607
|
+
return T_approx
|
|
2608
|
+
|
|
2609
|
+
|
|
2610
|
+
@njit(nogil=True, parallel=True)
|
|
2611
|
+
def tt_error_order10(T, G0, G1, G2, G3, G4, G5, G6, G7, G8, G9, dims, L):
|
|
2612
|
+
a, b, c, d, e, f, g, h, i, j = dims
|
|
2613
|
+
T_approx = empty(dims, dtype=float64)
|
|
2614
|
+
|
|
2615
|
+
for i0 in prange(a):
|
|
2616
|
+
for i1 in range(b):
|
|
2617
|
+
for i2 in range(c):
|
|
2618
|
+
for i3 in range(d):
|
|
2619
|
+
for i4 in range(e):
|
|
2620
|
+
for i5 in range(f):
|
|
2621
|
+
for i6 in range(g):
|
|
2622
|
+
for i7 in range(h):
|
|
2623
|
+
for i8 in range(i):
|
|
2624
|
+
for i9 in range(j):
|
|
2625
|
+
A = G0[i0,:]
|
|
2626
|
+
B = dot(A, G1[:,i1,:])
|
|
2627
|
+
C = dot(B, G2[:,i2,:])
|
|
2628
|
+
D = dot(C, G3[:,i3,:])
|
|
2629
|
+
E = dot(D, G4[:,i4,:])
|
|
2630
|
+
F = dot(E, G5[:,i5,:])
|
|
2631
|
+
G = dot(F, G6[:,i6,:])
|
|
2632
|
+
H = dot(G, G7[:,i7,:])
|
|
2633
|
+
I = dot(H, G8[:,i8,:])
|
|
2634
|
+
T_approx[i0,i1,i2,i3,i4,i5,i6,i7,i8,i9] = dot(I, G9[:,i9])
|
|
2635
|
+
|
|
2636
|
+
return T_approx
|
|
2637
|
+
|
|
2638
|
+
|
|
2639
|
+
@njit(nogil=True, parallel=True)
|
|
2640
|
+
def tt_error_order11(T, G0, G1, G2, G3, G4, G5, G6, G7, G8, G9, G10, dims, L):
|
|
2641
|
+
a, b, c, d, e, f, g, h, i, j, k = dims
|
|
2642
|
+
T_approx = empty(dims, dtype=float64)
|
|
2643
|
+
|
|
2644
|
+
for i0 in prange(a):
|
|
2645
|
+
for i1 in range(b):
|
|
2646
|
+
for i2 in range(c):
|
|
2647
|
+
for i3 in range(d):
|
|
2648
|
+
for i4 in range(e):
|
|
2649
|
+
for i5 in range(f):
|
|
2650
|
+
for i6 in range(g):
|
|
2651
|
+
for i7 in range(h):
|
|
2652
|
+
for i8 in range(i):
|
|
2653
|
+
for i9 in range(j):
|
|
2654
|
+
for i10 in range(k):
|
|
2655
|
+
A = G0[i0,:]
|
|
2656
|
+
B = dot(A, G1[:,i1,:])
|
|
2657
|
+
C = dot(B, G2[:,i2,:])
|
|
2658
|
+
D = dot(C, G3[:,i3,:])
|
|
2659
|
+
E = dot(D, G4[:,i4,:])
|
|
2660
|
+
F = dot(E, G5[:,i5,:])
|
|
2661
|
+
G = dot(F, G6[:,i6,:])
|
|
2662
|
+
H = dot(G, G7[:,i7,:])
|
|
2663
|
+
I = dot(H, G8[:,i8,:])
|
|
2664
|
+
J = dot(I, G9[:,i9,:])
|
|
2665
|
+
T_approx[i0,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10] = dot(J, G10[:,i10])
|
|
2666
|
+
|
|
2667
|
+
return T_approx
|
|
2668
|
+
|
|
2669
|
+
|
|
2670
|
+
@njit(nogil=True, parallel=True)
|
|
2671
|
+
def tt_error_order12(T, G0, G1, G2, G3, G4, G5, G6, G7, G8, G9, G10, G11, dims, L):
|
|
2672
|
+
a, b, c, d, e, f, g, h, i, j, k, m = dims
|
|
2673
|
+
T_approx = empty(dims, dtype=float64)
|
|
2674
|
+
|
|
2675
|
+
for i0 in prange(a):
|
|
2676
|
+
for i1 in range(b):
|
|
2677
|
+
for i2 in range(c):
|
|
2678
|
+
for i3 in range(d):
|
|
2679
|
+
for i4 in range(e):
|
|
2680
|
+
for i5 in range(f):
|
|
2681
|
+
for i6 in range(g):
|
|
2682
|
+
for i7 in range(h):
|
|
2683
|
+
for i8 in range(i):
|
|
2684
|
+
for i9 in range(j):
|
|
2685
|
+
for i10 in range(k):
|
|
2686
|
+
for i11 in range(m):
|
|
2687
|
+
A = G0[i0,:]
|
|
2688
|
+
B = dot(A, G1[:,i1,:])
|
|
2689
|
+
C = dot(B, G2[:,i2,:])
|
|
2690
|
+
D = dot(C, G3[:,i3,:])
|
|
2691
|
+
E = dot(D, G4[:,i4,:])
|
|
2692
|
+
F = dot(E, G5[:,i5,:])
|
|
2693
|
+
G = dot(F, G6[:,i6,:])
|
|
2694
|
+
H = dot(G, G7[:,i7,:])
|
|
2695
|
+
I = dot(H, G8[:,i8,:])
|
|
2696
|
+
J = dot(I, G9[:,i9,:])
|
|
2697
|
+
K = dot(J, G10[:,i10,:])
|
|
2698
|
+
T_approx[i0,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11] = dot(K, G11[:,i11])
|
|
2699
|
+
|
|
2700
|
+
return T_approx
|
|
2701
|
+
|
|
2702
|
+
|
|
2703
|
+
@njit(nogil=True, parallel=True)
|
|
2704
|
+
def sparse_multilin_mult_order3(U, data, S, dims):
|
|
2705
|
+
a, b, c = dims
|
|
2706
|
+
nnz = len(data[0])
|
|
2707
|
+
|
|
2708
|
+
for i0 in prange(a):
|
|
2709
|
+
u0 = U[0][i0,:] * data[i0]
|
|
2710
|
+
u1 = zeros(nnz, dtype=float64)
|
|
2711
|
+
for i1 in range(b):
|
|
2712
|
+
for k in range(nnz):
|
|
2713
|
+
u1[k] = u0[k] * U[1][i1,k]
|
|
2714
|
+
for i2 in range(c):
|
|
2715
|
+
s = 0
|
|
2716
|
+
for k in range(nnz):
|
|
2717
|
+
s += (u1[k]*U[2][i2,k])
|
|
2718
|
+
S[i0, i1, i2] = s
|
|
2719
|
+
|
|
2720
|
+
return S
|
|
2721
|
+
|
|
2722
|
+
|
|
2723
|
+
@njit(nogil=True, parallel=True)
|
|
2724
|
+
def sparse_multilin_mult_order4(U, data, S, dims):
|
|
2725
|
+
a, b, c, d = dims
|
|
2726
|
+
nnz = len(data[0])
|
|
2727
|
+
|
|
2728
|
+
for i0 in prange(a):
|
|
2729
|
+
u0 = U[0][i0,:] * data[i0]
|
|
2730
|
+
u1 = zeros(nnz, dtype=float64)
|
|
2731
|
+
u2 = zeros(nnz, dtype=float64)
|
|
2732
|
+
for i1 in range(b):
|
|
2733
|
+
for k in range(nnz):
|
|
2734
|
+
u1[k] = u0[k] * U[1][i1,k]
|
|
2735
|
+
for i2 in range(c):
|
|
2736
|
+
for k in range(nnz):
|
|
2737
|
+
u2[k] = u1[k] * U[2][i2,k]
|
|
2738
|
+
for i3 in range(d):
|
|
2739
|
+
s = 0
|
|
2740
|
+
for k in range(nnz):
|
|
2741
|
+
s += (u2[k]*U[3][i3,k])
|
|
2742
|
+
S[i0, i1, i2, i3] = s
|
|
2743
|
+
|
|
2744
|
+
return S
|
|
2745
|
+
|
|
2746
|
+
|
|
2747
|
+
@njit(nogil=True, parallel=True)
|
|
2748
|
+
def sparse_multilin_mult_order5(U, data, S, dims):
|
|
2749
|
+
a, b, c, d, e = dims
|
|
2750
|
+
nnz = len(data[0])
|
|
2751
|
+
|
|
2752
|
+
for i0 in prange(a):
|
|
2753
|
+
u0 = U[0][i0,:] * data[i0]
|
|
2754
|
+
u1 = zeros(nnz, dtype=float64)
|
|
2755
|
+
u2 = zeros(nnz, dtype=float64)
|
|
2756
|
+
u3 = zeros(nnz, dtype=float64)
|
|
2757
|
+
for i1 in range(b):
|
|
2758
|
+
for k in range(nnz):
|
|
2759
|
+
u1[k] = u0[k] * U[1][i1,k]
|
|
2760
|
+
for i2 in range(c):
|
|
2761
|
+
for k in range(nnz):
|
|
2762
|
+
u2[k] = u1[k] * U[2][i2,k]
|
|
2763
|
+
for i3 in range(d):
|
|
2764
|
+
u3 = u2 * U[3][i3,:]
|
|
2765
|
+
for k in range(nnz):
|
|
2766
|
+
u3[k] = u2[k] * U[3][i3,k]
|
|
2767
|
+
for i4 in range(e):
|
|
2768
|
+
s = 0
|
|
2769
|
+
for k in range(nnz):
|
|
2770
|
+
s += (u3[k]*U[4][i4,k])
|
|
2771
|
+
S[i0, i1, i2, i3, i4] = s
|
|
2772
|
+
|
|
2773
|
+
return S
|
|
2774
|
+
|
|
2775
|
+
|
|
2776
|
+
@njit(nogil=True, parallel=True)
|
|
2777
|
+
def sparse_multilin_mult_order6(U, data, S, dims):
|
|
2778
|
+
a, b, c, d, e, f = dims
|
|
2779
|
+
nnz = len(data[0])
|
|
2780
|
+
|
|
2781
|
+
for i0 in prange(a):
|
|
2782
|
+
u0 = U[0][i0,:] * data[i0]
|
|
2783
|
+
u1 = zeros(nnz, dtype=float64)
|
|
2784
|
+
u2 = zeros(nnz, dtype=float64)
|
|
2785
|
+
u3 = zeros(nnz, dtype=float64)
|
|
2786
|
+
u4 = zeros(nnz, dtype=float64)
|
|
2787
|
+
u5 = zeros(nnz, dtype=float64)
|
|
2788
|
+
for i1 in range(b):
|
|
2789
|
+
for k in range(nnz):
|
|
2790
|
+
u1[k] = u0[k] * U[1][i1,k]
|
|
2791
|
+
for i2 in range(c):
|
|
2792
|
+
for k in range(nnz):
|
|
2793
|
+
u2[k] = u1[k] * U[2][i2,k]
|
|
2794
|
+
for i3 in range(d):
|
|
2795
|
+
u3 = u2 * U[3][i3,:]
|
|
2796
|
+
for k in range(nnz):
|
|
2797
|
+
u3[k] = u2[k] * U[3][i3,k]
|
|
2798
|
+
for i4 in range(e):
|
|
2799
|
+
for k in range(nnz):
|
|
2800
|
+
u4[k] = u3[k] * U[4][i4,k]
|
|
2801
|
+
for i5 in range(f):
|
|
2802
|
+
s = 0
|
|
2803
|
+
for k in range(nnz):
|
|
2804
|
+
s += (u4[k]*U[5][i5,k])
|
|
2805
|
+
S[i0, i1, i2, i3, i4, i5] = s
|
|
2806
|
+
|
|
2807
|
+
return S
|
|
2808
|
+
|
|
2809
|
+
|
|
2810
|
+
@njit(nogil=True, parallel=True)
|
|
2811
|
+
def sparse_multilin_mult_order7(U, data, S, dims):
|
|
2812
|
+
a, b, c, d, e, f, g = dims
|
|
2813
|
+
nnz = len(data[0])
|
|
2814
|
+
|
|
2815
|
+
for i0 in prange(a):
|
|
2816
|
+
u0 = U[0][i0,:] * data[i0]
|
|
2817
|
+
u1 = zeros(nnz, dtype=float64)
|
|
2818
|
+
u2 = zeros(nnz, dtype=float64)
|
|
2819
|
+
u3 = zeros(nnz, dtype=float64)
|
|
2820
|
+
u4 = zeros(nnz, dtype=float64)
|
|
2821
|
+
u5 = zeros(nnz, dtype=float64)
|
|
2822
|
+
u6 = zeros(nnz, dtype=float64)
|
|
2823
|
+
for i1 in range(b):
|
|
2824
|
+
for k in range(nnz):
|
|
2825
|
+
u1[k] = u0[k] * U[1][i1,k]
|
|
2826
|
+
for i2 in range(c):
|
|
2827
|
+
for k in range(nnz):
|
|
2828
|
+
u2[k] = u1[k] * U[2][i2,k]
|
|
2829
|
+
for i3 in range(d):
|
|
2830
|
+
u3 = u2 * U[3][i3,:]
|
|
2831
|
+
for k in range(nnz):
|
|
2832
|
+
u3[k] = u2[k] * U[3][i3,k]
|
|
2833
|
+
for i4 in range(e):
|
|
2834
|
+
for k in range(nnz):
|
|
2835
|
+
u4[k] = u3[k] * U[4][i4,k]
|
|
2836
|
+
for i5 in range(f):
|
|
2837
|
+
for k in range(nnz):
|
|
2838
|
+
u5[k] = u4[k] * U[5][i5,k]
|
|
2839
|
+
for i6 in range(g):
|
|
2840
|
+
s = 0
|
|
2841
|
+
for k in range(nnz):
|
|
2842
|
+
s += (u5[k]*U[6][i6,k])
|
|
2843
|
+
S[i0, i1, i2, i3, i4, i5, i6] = s
|
|
2844
|
+
|
|
2845
|
+
return S
|
|
2846
|
+
|
|
2847
|
+
|
|
2848
|
+
@njit(nogil=True, parallel=True)
|
|
2849
|
+
def sparse_multilin_mult_order8(U, data, S, dims):
|
|
2850
|
+
a, b, c, d, e, f, g, h = dims
|
|
2851
|
+
nnz = len(data[0])
|
|
2852
|
+
|
|
2853
|
+
for i0 in prange(a):
|
|
2854
|
+
u0 = U[0][i0,:] * data[i0]
|
|
2855
|
+
u1 = zeros(nnz, dtype=float64)
|
|
2856
|
+
u2 = zeros(nnz, dtype=float64)
|
|
2857
|
+
u3 = zeros(nnz, dtype=float64)
|
|
2858
|
+
u4 = zeros(nnz, dtype=float64)
|
|
2859
|
+
u5 = zeros(nnz, dtype=float64)
|
|
2860
|
+
u6 = zeros(nnz, dtype=float64)
|
|
2861
|
+
u7 = zeros(nnz, dtype=float64)
|
|
2862
|
+
for i1 in range(b):
|
|
2863
|
+
for k in range(nnz):
|
|
2864
|
+
u1[k] = u0[k] * U[1][i1,k]
|
|
2865
|
+
for i2 in range(c):
|
|
2866
|
+
for k in range(nnz):
|
|
2867
|
+
u2[k] = u1[k] * U[2][i2,k]
|
|
2868
|
+
for i3 in range(d):
|
|
2869
|
+
u3 = u2 * U[3][i3,:]
|
|
2870
|
+
for k in range(nnz):
|
|
2871
|
+
u3[k] = u2[k] * U[3][i3,k]
|
|
2872
|
+
for i4 in range(e):
|
|
2873
|
+
for k in range(nnz):
|
|
2874
|
+
u4[k] = u3[k] * U[4][i4,k]
|
|
2875
|
+
for i5 in range(f):
|
|
2876
|
+
for k in range(nnz):
|
|
2877
|
+
u5[k] = u4[k] * U[5][i5,k]
|
|
2878
|
+
for i6 in range(g):
|
|
2879
|
+
for k in range(nnz):
|
|
2880
|
+
u6[k] = u5[k] * U[6][i6,k]
|
|
2881
|
+
for i7 in range(h):
|
|
2882
|
+
s = 0
|
|
2883
|
+
for k in range(nnz):
|
|
2884
|
+
s += (u6[k]*U[7][i7,k])
|
|
2885
|
+
S[i0, i1, i2, i3, i4, i5, i6, i7] = s
|
|
2886
|
+
|
|
2887
|
+
return S
|
|
2888
|
+
|
|
2889
|
+
|
|
2890
|
+
@njit(nogil=True, parallel=True)
|
|
2891
|
+
def sparse_multilin_mult_order9(U, data, S, dims):
|
|
2892
|
+
a, b, c, d, e, f, g, h, i = dims
|
|
2893
|
+
nnz = len(data[0])
|
|
2894
|
+
|
|
2895
|
+
for i0 in prange(a):
|
|
2896
|
+
u0 = U[0][i0,:] * data[i0]
|
|
2897
|
+
u1 = zeros(nnz, dtype=float64)
|
|
2898
|
+
u2 = zeros(nnz, dtype=float64)
|
|
2899
|
+
u3 = zeros(nnz, dtype=float64)
|
|
2900
|
+
u4 = zeros(nnz, dtype=float64)
|
|
2901
|
+
u5 = zeros(nnz, dtype=float64)
|
|
2902
|
+
u6 = zeros(nnz, dtype=float64)
|
|
2903
|
+
u7 = zeros(nnz, dtype=float64)
|
|
2904
|
+
u8 = zeros(nnz, dtype=float64)
|
|
2905
|
+
for i1 in range(b):
|
|
2906
|
+
for k in range(nnz):
|
|
2907
|
+
u1[k] = u0[k] * U[1][i1,k]
|
|
2908
|
+
for i2 in range(c):
|
|
2909
|
+
for k in range(nnz):
|
|
2910
|
+
u2[k] = u1[k] * U[2][i2,k]
|
|
2911
|
+
for i3 in range(d):
|
|
2912
|
+
u3 = u2 * U[3][i3,:]
|
|
2913
|
+
for k in range(nnz):
|
|
2914
|
+
u3[k] = u2[k] * U[3][i3,k]
|
|
2915
|
+
for i4 in range(e):
|
|
2916
|
+
for k in range(nnz):
|
|
2917
|
+
u4[k] = u3[k] * U[4][i4,k]
|
|
2918
|
+
for i5 in range(f):
|
|
2919
|
+
for k in range(nnz):
|
|
2920
|
+
u5[k] = u4[k] * U[5][i5,k]
|
|
2921
|
+
for i6 in range(g):
|
|
2922
|
+
for k in range(nnz):
|
|
2923
|
+
u6[k] = u5[k] * U[6][i6,k]
|
|
2924
|
+
for i7 in range(h):
|
|
2925
|
+
for k in range(nnz):
|
|
2926
|
+
u7[k] = u6[k] * U[7][i7,k]
|
|
2927
|
+
for i8 in range(i):
|
|
2928
|
+
s = 0
|
|
2929
|
+
for k in range(nnz):
|
|
2930
|
+
s += (u7[k]*U[8][i8,k])
|
|
2931
|
+
S[i0, i1, i2, i3, i4, i5, i6, i7, i8] = s
|
|
2932
|
+
|
|
2933
|
+
return S
|
|
2934
|
+
|
|
2935
|
+
|
|
2936
|
+
@njit(nogil=True, parallel=True)
|
|
2937
|
+
def sparse_multilin_mult_order10(U, data, S, dims):
|
|
2938
|
+
a, b, c, d, e, f, g, h, i, j = dims
|
|
2939
|
+
nnz = len(data[0])
|
|
2940
|
+
|
|
2941
|
+
for i0 in prange(a):
|
|
2942
|
+
u0 = U[0][i0,:] * data[i0]
|
|
2943
|
+
u1 = zeros(nnz, dtype=float64)
|
|
2944
|
+
u2 = zeros(nnz, dtype=float64)
|
|
2945
|
+
u3 = zeros(nnz, dtype=float64)
|
|
2946
|
+
u4 = zeros(nnz, dtype=float64)
|
|
2947
|
+
u5 = zeros(nnz, dtype=float64)
|
|
2948
|
+
u6 = zeros(nnz, dtype=float64)
|
|
2949
|
+
u7 = zeros(nnz, dtype=float64)
|
|
2950
|
+
u8 = zeros(nnz, dtype=float64)
|
|
2951
|
+
u9 = zeros(nnz, dtype=float64)
|
|
2952
|
+
for i1 in range(b):
|
|
2953
|
+
for k in range(nnz):
|
|
2954
|
+
u1[k] = u0[k] * U[1][i1,k]
|
|
2955
|
+
for i2 in range(c):
|
|
2956
|
+
for k in range(nnz):
|
|
2957
|
+
u2[k] = u1[k] * U[2][i2,k]
|
|
2958
|
+
for i3 in range(d):
|
|
2959
|
+
u3 = u2 * U[3][i3,:]
|
|
2960
|
+
for k in range(nnz):
|
|
2961
|
+
u3[k] = u2[k] * U[3][i3,k]
|
|
2962
|
+
for i4 in range(e):
|
|
2963
|
+
for k in range(nnz):
|
|
2964
|
+
u4[k] = u3[k] * U[4][i4,k]
|
|
2965
|
+
for i5 in range(f):
|
|
2966
|
+
for k in range(nnz):
|
|
2967
|
+
u5[k] = u4[k] * U[5][i5,k]
|
|
2968
|
+
for i6 in range(g):
|
|
2969
|
+
for k in range(nnz):
|
|
2970
|
+
u6[k] = u5[k] * U[6][i6,k]
|
|
2971
|
+
for i7 in range(h):
|
|
2972
|
+
for k in range(nnz):
|
|
2973
|
+
u7[k] = u6[k] * U[7][i7,k]
|
|
2974
|
+
for i8 in range(i):
|
|
2975
|
+
for k in range(nnz):
|
|
2976
|
+
u8[k] = u7[k] * U[8][i8,k]
|
|
2977
|
+
for i9 in range(j):
|
|
2978
|
+
s = 0
|
|
2979
|
+
for k in range(nnz):
|
|
2980
|
+
s += (u8[k]*U[9][i9,k])
|
|
2981
|
+
S[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9] = s
|
|
2982
|
+
|
|
2983
|
+
return S
|
|
2984
|
+
|
|
2985
|
+
|
|
2986
|
+
@njit(nogil=True, parallel=True)
|
|
2987
|
+
def sparse_multilin_mult_order11(U, data, S, dims):
|
|
2988
|
+
a, b, c, d, e, f, g, h, i, j, m = dims
|
|
2989
|
+
nnz = len(data[0])
|
|
2990
|
+
|
|
2991
|
+
for i0 in prange(a):
|
|
2992
|
+
u0 = U[0][i0,:] * data[i0]
|
|
2993
|
+
u1 = zeros(nnz, dtype=float64)
|
|
2994
|
+
u2 = zeros(nnz, dtype=float64)
|
|
2995
|
+
u3 = zeros(nnz, dtype=float64)
|
|
2996
|
+
u4 = zeros(nnz, dtype=float64)
|
|
2997
|
+
u5 = zeros(nnz, dtype=float64)
|
|
2998
|
+
u6 = zeros(nnz, dtype=float64)
|
|
2999
|
+
u7 = zeros(nnz, dtype=float64)
|
|
3000
|
+
u8 = zeros(nnz, dtype=float64)
|
|
3001
|
+
u9 = zeros(nnz, dtype=float64)
|
|
3002
|
+
u10 = zeros(nnz, dtype=float64)
|
|
3003
|
+
for i1 in range(b):
|
|
3004
|
+
for k in range(nnz):
|
|
3005
|
+
u1[k] = u0[k] * U[1][i1,k]
|
|
3006
|
+
for i2 in range(c):
|
|
3007
|
+
for k in range(nnz):
|
|
3008
|
+
u2[k] = u1[k] * U[2][i2,k]
|
|
3009
|
+
for i3 in range(d):
|
|
3010
|
+
u3 = u2 * U[3][i3,:]
|
|
3011
|
+
for k in range(nnz):
|
|
3012
|
+
u3[k] = u2[k] * U[3][i3,k]
|
|
3013
|
+
for i4 in range(e):
|
|
3014
|
+
for k in range(nnz):
|
|
3015
|
+
u4[k] = u3[k] * U[4][i4,k]
|
|
3016
|
+
for i5 in range(f):
|
|
3017
|
+
for k in range(nnz):
|
|
3018
|
+
u5[k] = u4[k] * U[5][i5,k]
|
|
3019
|
+
for i6 in range(g):
|
|
3020
|
+
for k in range(nnz):
|
|
3021
|
+
u6[k] = u5[k] * U[6][i6,k]
|
|
3022
|
+
for i7 in range(h):
|
|
3023
|
+
for k in range(nnz):
|
|
3024
|
+
u7[k] = u6[k] * U[7][i7,k]
|
|
3025
|
+
for i8 in range(i):
|
|
3026
|
+
for k in range(nnz):
|
|
3027
|
+
u8[k] = u7[k] * U[8][i8,k]
|
|
3028
|
+
for i9 in range(j):
|
|
3029
|
+
for k in range(nnz):
|
|
3030
|
+
u9[k] = u8[k] * U[9][i9,k]
|
|
3031
|
+
for i10 in range(m):
|
|
3032
|
+
s = 0
|
|
3033
|
+
for k in range(nnz):
|
|
3034
|
+
s += (u9[k]*U[10][i10,k])
|
|
3035
|
+
S[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10] = s
|
|
3036
|
+
|
|
3037
|
+
return S
|
|
3038
|
+
|
|
3039
|
+
|
|
3040
|
+
@njit(nogil=True, parallel=True)
|
|
3041
|
+
def sparse_multilin_mult_order12(U, data, S, dims):
|
|
3042
|
+
a, b, c, d, e, f, g, h, i, j, m, n = dims
|
|
3043
|
+
nnz = len(data[0])
|
|
3044
|
+
|
|
3045
|
+
for i0 in prange(a):
|
|
3046
|
+
u0 = U[0][i0,:] * data[i0]
|
|
3047
|
+
u1 = zeros(nnz, dtype=float64)
|
|
3048
|
+
u2 = zeros(nnz, dtype=float64)
|
|
3049
|
+
u3 = zeros(nnz, dtype=float64)
|
|
3050
|
+
u4 = zeros(nnz, dtype=float64)
|
|
3051
|
+
u5 = zeros(nnz, dtype=float64)
|
|
3052
|
+
u6 = zeros(nnz, dtype=float64)
|
|
3053
|
+
u7 = zeros(nnz, dtype=float64)
|
|
3054
|
+
u8 = zeros(nnz, dtype=float64)
|
|
3055
|
+
u9 = zeros(nnz, dtype=float64)
|
|
3056
|
+
u10 = zeros(nnz, dtype=float64)
|
|
3057
|
+
u11 = zeros(nnz, dtype=float64)
|
|
3058
|
+
for i1 in range(b):
|
|
3059
|
+
for k in range(nnz):
|
|
3060
|
+
u1[k] = u0[k] * U[1][i1,k]
|
|
3061
|
+
for i2 in range(c):
|
|
3062
|
+
for k in range(nnz):
|
|
3063
|
+
u2[k] = u1[k] * U[2][i2,k]
|
|
3064
|
+
for i3 in range(d):
|
|
3065
|
+
u3 = u2 * U[3][i3,:]
|
|
3066
|
+
for k in range(nnz):
|
|
3067
|
+
u3[k] = u2[k] * U[3][i3,k]
|
|
3068
|
+
for i4 in range(e):
|
|
3069
|
+
for k in range(nnz):
|
|
3070
|
+
u4[k] = u3[k] * U[4][i4,k]
|
|
3071
|
+
for i5 in range(f):
|
|
3072
|
+
for k in range(nnz):
|
|
3073
|
+
u5[k] = u4[k] * U[5][i5,k]
|
|
3074
|
+
for i6 in range(g):
|
|
3075
|
+
for k in range(nnz):
|
|
3076
|
+
u6[k] = u5[k] * U[6][i6,k]
|
|
3077
|
+
for i7 in range(h):
|
|
3078
|
+
for k in range(nnz):
|
|
3079
|
+
u7[k] = u6[k] * U[7][i7,k]
|
|
3080
|
+
for i8 in range(i):
|
|
3081
|
+
for k in range(nnz):
|
|
3082
|
+
u8[k] = u7[k] * U[8][i8,k]
|
|
3083
|
+
for i9 in range(j):
|
|
3084
|
+
for k in range(nnz):
|
|
3085
|
+
u9[k] = u8[k] * U[9][i9,k]
|
|
3086
|
+
for i10 in range(m):
|
|
3087
|
+
for k in range(nnz):
|
|
3088
|
+
u10[k] = u9[k] * U[10][i10,k]
|
|
3089
|
+
for i11 in range(n):
|
|
3090
|
+
s = 0
|
|
3091
|
+
for k in range(nnz):
|
|
3092
|
+
s += (u10[k]*U[11][i11,k])
|
|
3093
|
+
S[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11] = s
|
|
3094
|
+
|
|
3095
|
+
return S
|
|
3096
|
+
|
|
3097
|
+
|
|
3098
|
+
@njit(nogil=True, parallel=True)
|
|
3099
|
+
def sparse_multilin_mult_order3_direct(S, U, idxs):
|
|
3100
|
+
dims_S = S.shape
|
|
3101
|
+
nnz = len(idxs)
|
|
3102
|
+
data_approx = empty(nnz, dtype=float64)
|
|
3103
|
+
|
|
3104
|
+
for i in prange(nnz):
|
|
3105
|
+
s = 0
|
|
3106
|
+
j = idxs[i]
|
|
3107
|
+
for i0 in range(dims_S[0]):
|
|
3108
|
+
for i1 in range(dims_S[1]):
|
|
3109
|
+
for i2 in range(dims_S[2]):
|
|
3110
|
+
s += U[0][j[0],i0] * U[1][j[1],i1] * U[2][j[2],i2] * S[i0,i1,i2]
|
|
3111
|
+
data_approx[i] = s
|
|
3112
|
+
|
|
3113
|
+
return data_approx
|
|
3114
|
+
|
|
3115
|
+
|
|
3116
|
+
@njit(nogil=True, parallel=True)
|
|
3117
|
+
def sparse_multilin_mult_order4_direct(S, U, idxs):
|
|
3118
|
+
dims_S = S.shape
|
|
3119
|
+
nnz = len(idxs)
|
|
3120
|
+
data_approx = empty(nnz, dtype=float64)
|
|
3121
|
+
|
|
3122
|
+
for i in prange(nnz):
|
|
3123
|
+
s = 0
|
|
3124
|
+
j = idxs[i]
|
|
3125
|
+
for i0 in range(dims_S[0]):
|
|
3126
|
+
for i1 in range(dims_S[1]):
|
|
3127
|
+
for i2 in range(dims_S[2]):
|
|
3128
|
+
for i3 in range(dims_S[3]):
|
|
3129
|
+
s += U[0][j[0],i0] * U[1][j[1],i1] * U[2][j[2],i2] * U[3][j[3],i3] * S[i0,i1,i2,i3]
|
|
3130
|
+
data_approx[i] = s
|
|
3131
|
+
|
|
3132
|
+
return data_approx
|
|
3133
|
+
|
|
3134
|
+
|
|
3135
|
+
@njit(nogil=True, parallel=True)
|
|
3136
|
+
def sparse_multilin_mult_order5_direct(S, U, idxs):
|
|
3137
|
+
dims_S = S.shape
|
|
3138
|
+
nnz = len(idxs)
|
|
3139
|
+
data_approx = empty(nnz, dtype=float64)
|
|
3140
|
+
|
|
3141
|
+
for i in prange(nnz):
|
|
3142
|
+
s = 0
|
|
3143
|
+
j = idxs[i]
|
|
3144
|
+
for i0 in range(dims_S[0]):
|
|
3145
|
+
for i1 in range(dims_S[1]):
|
|
3146
|
+
for i2 in range(dims_S[2]):
|
|
3147
|
+
for i3 in range(dims_S[3]):
|
|
3148
|
+
for i4 in range(dims_S[4]):
|
|
3149
|
+
s += U[0][j[0],i0] * U[1][j[1],i1] * U[2][j[2],i2] * U[3][j[3],i3] * U[4][j[4],i4] * S[i0,i1,i2,i3,i4]
|
|
3150
|
+
data_approx[i] = s
|
|
3151
|
+
|
|
3152
|
+
return data_approx
|
|
3153
|
+
|
|
3154
|
+
|
|
3155
|
+
@njit(nogil=True, parallel=True)
|
|
3156
|
+
def sparse_multilin_mult_order6_direct(S, U, idxs):
|
|
3157
|
+
dims_S = S.shape
|
|
3158
|
+
nnz = len(idxs)
|
|
3159
|
+
data_approx = empty(nnz, dtype=float64)
|
|
3160
|
+
|
|
3161
|
+
for i in prange(nnz):
|
|
3162
|
+
s = 0
|
|
3163
|
+
j = idxs[i]
|
|
3164
|
+
for i0 in range(dims_S[0]):
|
|
3165
|
+
for i1 in range(dims_S[1]):
|
|
3166
|
+
for i2 in range(dims_S[2]):
|
|
3167
|
+
for i3 in range(dims_S[3]):
|
|
3168
|
+
for i4 in range(dims_S[4]):
|
|
3169
|
+
for i5 in range(dims_S[5]):
|
|
3170
|
+
s += U[0][j[0],i0] * U[1][j[1],i1] * U[2][j[2],i2] * U[3][j[3],i3] * U[4][j[4],i4] * U[5][j[5],i5] * S[i0,i1,i2,i3,i4,i5]
|
|
3171
|
+
data_approx[i] = s
|
|
3172
|
+
|
|
3173
|
+
return data_approx
|
|
3174
|
+
|
|
3175
|
+
|
|
3176
|
+
@njit(nogil=True, parallel=True)
|
|
3177
|
+
def sparse_multilin_mult_order7_direct(S, U, idxs):
|
|
3178
|
+
dims_S = S.shape
|
|
3179
|
+
nnz = len(idxs)
|
|
3180
|
+
data_approx = empty(nnz, dtype=float64)
|
|
3181
|
+
|
|
3182
|
+
for i in prange(nnz):
|
|
3183
|
+
s = 0
|
|
3184
|
+
j = idxs[i]
|
|
3185
|
+
for i0 in range(dims_S[0]):
|
|
3186
|
+
for i1 in range(dims_S[1]):
|
|
3187
|
+
for i2 in range(dims_S[2]):
|
|
3188
|
+
for i3 in range(dims_S[3]):
|
|
3189
|
+
for i4 in range(dims_S[4]):
|
|
3190
|
+
for i5 in range(dims_S[5]):
|
|
3191
|
+
for i6 in range(dims_S[6]):
|
|
3192
|
+
s += U[0][j[0],i0] * U[1][j[1],i1] * U[2][j[2],i2] * U[3][j[3],i3] * U[4][j[4],i4] * U[5][j[5],i5] * U[6][j[6],i6] * S[i0,i1,i2,i3,i4,i5,i6]
|
|
3193
|
+
data_approx[i] = s
|
|
3194
|
+
|
|
3195
|
+
return data_approx
|
|
3196
|
+
|
|
3197
|
+
|
|
3198
|
+
@njit(nogil=True, parallel=True)
|
|
3199
|
+
def sparse_multilin_mult_order8_direct(S, U, idxs):
|
|
3200
|
+
dims_S = S.shape
|
|
3201
|
+
nnz = len(idxs)
|
|
3202
|
+
data_approx = empty(nnz, dtype=float64)
|
|
3203
|
+
|
|
3204
|
+
for i in prange(nnz):
|
|
3205
|
+
s = 0
|
|
3206
|
+
j = idxs[i]
|
|
3207
|
+
for i0 in range(dims_S[0]):
|
|
3208
|
+
for i1 in range(dims_S[1]):
|
|
3209
|
+
for i2 in range(dims_S[2]):
|
|
3210
|
+
for i3 in range(dims_S[3]):
|
|
3211
|
+
for i4 in range(dims_S[4]):
|
|
3212
|
+
for i5 in range(dims_S[5]):
|
|
3213
|
+
for i6 in range(dims_S[6]):
|
|
3214
|
+
for i7 in range(dims_S[7]):
|
|
3215
|
+
s += U[0][j[0],i0] * U[1][j[1],i1] * U[2][j[2],i2] * U[3][j[3],i3] * U[4][j[4],i4] * U[5][j[5],i5] * U[6][j[6],i6] * U[7][j[7],i7] * S[i0,i1,i2,i3,i4,i5,i6,i7]
|
|
3216
|
+
data_approx[i] = s
|
|
3217
|
+
|
|
3218
|
+
return data_approx
|
|
3219
|
+
|
|
3220
|
+
|
|
3221
|
+
@njit(nogil=True, parallel=True)
|
|
3222
|
+
def sparse_multilin_mult_order9_direct(S, U, idxs):
|
|
3223
|
+
dims_S = S.shape
|
|
3224
|
+
nnz = len(idxs)
|
|
3225
|
+
data_approx = empty(nnz, dtype=float64)
|
|
3226
|
+
|
|
3227
|
+
for i in prange(nnz):
|
|
3228
|
+
s = 0
|
|
3229
|
+
j = idxs[i]
|
|
3230
|
+
for i0 in range(dims_S[0]):
|
|
3231
|
+
for i1 in range(dims_S[1]):
|
|
3232
|
+
for i2 in range(dims_S[2]):
|
|
3233
|
+
for i3 in range(dims_S[3]):
|
|
3234
|
+
for i4 in range(dims_S[4]):
|
|
3235
|
+
for i5 in range(dims_S[5]):
|
|
3236
|
+
for i6 in range(dims_S[6]):
|
|
3237
|
+
for i7 in range(dims_S[7]):
|
|
3238
|
+
for i8 in range(dims_S[8]):
|
|
3239
|
+
s += U[0][j[0],i0] * U[1][j[1],i1] * U[2][j[2],i2] * U[3][j[3],i3] * U[4][j[4],i4] * U[5][j[5],i5] * U[6][j[6],i6] * U[7][j[7],i7] * U[8][j[8],i8] * S[i0,i1,i2,i3,i4,i5,i6,i7,i8]
|
|
3240
|
+
data_approx[i] = s
|
|
3241
|
+
|
|
3242
|
+
return data_approx
|
|
3243
|
+
|
|
3244
|
+
|
|
3245
|
+
@njit(nogil=True, parallel=True)
|
|
3246
|
+
def sparse_multilin_mult_order10_direct(S, U, idxs):
|
|
3247
|
+
dims_S = S.shape
|
|
3248
|
+
nnz = len(idxs)
|
|
3249
|
+
data_approx = empty(nnz, dtype=float64)
|
|
3250
|
+
|
|
3251
|
+
for i in prange(nnz):
|
|
3252
|
+
s = 0
|
|
3253
|
+
j = idxs[i]
|
|
3254
|
+
for i0 in range(dims_S[0]):
|
|
3255
|
+
for i1 in range(dims_S[1]):
|
|
3256
|
+
for i2 in range(dims_S[2]):
|
|
3257
|
+
for i3 in range(dims_S[3]):
|
|
3258
|
+
for i4 in range(dims_S[4]):
|
|
3259
|
+
for i5 in range(dims_S[5]):
|
|
3260
|
+
for i6 in range(dims_S[6]):
|
|
3261
|
+
for i7 in range(dims_S[7]):
|
|
3262
|
+
for i8 in range(dims_S[8]):
|
|
3263
|
+
for i9 in range(dims_S[9]):
|
|
3264
|
+
s += U[0][j[0],i0] * U[1][j[1],i1] * U[2][j[2],i2] * U[3][j[3],i3] * U[4][j[4],i4] * U[5][j[5],i5] * U[6][j[6],i6] * U[7][j[7],i7] * U[8][j[8],i8] * U[9][j[9],i9] * S[i0,i1,i2,i3,i4,i5,i6,i7,i8,i9]
|
|
3265
|
+
data_approx[i] = s
|
|
3266
|
+
|
|
3267
|
+
return data_approx
|
|
3268
|
+
|
|
3269
|
+
|
|
3270
|
+
@njit(nogil=True, parallel=True)
|
|
3271
|
+
def sparse_multilin_mult_order11_direct(S, U, idxs):
|
|
3272
|
+
dims_S = S.shape
|
|
3273
|
+
nnz = len(idxs)
|
|
3274
|
+
data_approx = empty(nnz, dtype=float64)
|
|
3275
|
+
|
|
3276
|
+
for i in prange(nnz):
|
|
3277
|
+
s = 0
|
|
3278
|
+
j = idxs[i]
|
|
3279
|
+
for i0 in range(dims_S[0]):
|
|
3280
|
+
for i1 in range(dims_S[1]):
|
|
3281
|
+
for i2 in range(dims_S[2]):
|
|
3282
|
+
for i3 in range(dims_S[3]):
|
|
3283
|
+
for i4 in range(dims_S[4]):
|
|
3284
|
+
for i5 in range(dims_S[5]):
|
|
3285
|
+
for i6 in range(dims_S[6]):
|
|
3286
|
+
for i7 in range(dims_S[7]):
|
|
3287
|
+
for i8 in range(dims_S[8]):
|
|
3288
|
+
for i9 in range(dims_S[9]):
|
|
3289
|
+
for i10 in range(dims_S[10]):
|
|
3290
|
+
s += U[0][j[0],i0] * U[1][j[1],i1] * U[2][j[2],i2] * U[3][j[3],i3] * U[4][j[4],i4] * U[5][j[5],i5] * U[6][j[6],i6] * U[7][j[7],i7] * U[8][j[8],i8] * U[9][j[9],i9] * U[10][j[10],i10] * S[i0,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10]
|
|
3291
|
+
data_approx[i] = s
|
|
3292
|
+
|
|
3293
|
+
return data_approx
|
|
3294
|
+
|
|
3295
|
+
|
|
3296
|
+
@njit(nogil=True, parallel=True)
|
|
3297
|
+
def sparse_multilin_mult_order12_direct(S, U, idxs):
|
|
3298
|
+
dims_S = S.shape
|
|
3299
|
+
nnz = len(idxs)
|
|
3300
|
+
data_approx = empty(nnz, dtype=float64)
|
|
3301
|
+
|
|
3302
|
+
for i in prange(nnz):
|
|
3303
|
+
s = 0
|
|
3304
|
+
j = idxs[i]
|
|
3305
|
+
for i0 in range(dims_S[0]):
|
|
3306
|
+
for i1 in range(dims_S[1]):
|
|
3307
|
+
for i2 in range(dims_S[2]):
|
|
3308
|
+
for i3 in range(dims_S[3]):
|
|
3309
|
+
for i4 in range(dims_S[4]):
|
|
3310
|
+
for i5 in range(dims_S[5]):
|
|
3311
|
+
for i6 in range(dims_S[6]):
|
|
3312
|
+
for i7 in range(dims_S[7]):
|
|
3313
|
+
for i8 in range(dims_S[8]):
|
|
3314
|
+
for i9 in range(dims_S[9]):
|
|
3315
|
+
for i10 in range(dims_S[10]):
|
|
3316
|
+
for i11 in range(dims_S[11]):
|
|
3317
|
+
s += U[0][j[0],i0] * U[1][j[1],i1] * U[2][j[2],i2] * U[3][j[3],i3] * U[4][j[4],i4] * U[5][j[5],i5] * U[6][j[6],i6] * U[7][j[7],i7] * U[8][j[8],i8] * U[9][j[9],i9] * U[10][j[10],i10] * U[11][j[11],i11] * S[i0,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11]
|
|
3318
|
+
data_approx[i] = s
|
|
3319
|
+
|
|
3320
|
+
return data_approx
|