v0.13.2
Loading...
Searching...
No Matches
Dg_Expr_equals.hpp
Go to the documentation of this file.
1/* Various assignment operators, including specializations to
2 Christof. I have to explicitly declare the second
3 operator= because otherwise the compiler will generate its own and
4 not use the template code. */
5
6#pragma once
7
8namespace FTensor
9{
10 /* T3dg=T3dg */
11
12 template <class A, class B, class U, int Dim01, int Dim2, char i, char j,
13 char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
14 void
15 T3dg_equals_T3dg(A &iter, const Dg_Expr<B, U, Dim01, Dim2, i, j, k> &result,
16 const Number<Current_Dim0> &, const Number<Current_Dim1> &,
17 const Number<Current_Dim2> &)
18 {
19 iter(Current_Dim0 - 1, Current_Dim1 - 1, Current_Dim2 - 1)
20 = result(Current_Dim0 - 1, Current_Dim1 - 1, Current_Dim2 - 1);
21 T3dg_equals_T3dg(iter, result, Number<Current_Dim0 - 1>(),
22 Number<Current_Dim1>(), Number<Current_Dim2>());
23 }
24
25 template <class A, class B, class U, int Dim01, int Dim2, char i, char j,
26 char k, int Current_Dim1, int Current_Dim2>
27 void
28 T3dg_equals_T3dg(A &iter, const Dg_Expr<B, U, Dim01, Dim2, i, j, k> &result,
29 const Number<1> &, const Number<Current_Dim1> &,
30 const Number<Current_Dim2> &)
31 {
32 iter(0, Current_Dim1 - 1, Current_Dim2 - 1)
33 = result(0, Current_Dim1 - 1, Current_Dim2 - 1);
34 T3dg_equals_T3dg(iter, result, Number<Current_Dim1 - 1>(),
35 Number<Current_Dim1 - 1>(), Number<Current_Dim2>());
36 }
37
38 template <class A, class B, class U, int Dim01, int Dim2, char i, char j,
39 char k, int Current_Dim2>
40 void
41 T3dg_equals_T3dg(A &iter, const Dg_Expr<B, U, Dim01, Dim2, i, j, k> &result,
42 const Number<1> &, const Number<1> &,
43 const Number<Current_Dim2> &)
44 {
45 iter(0, 0, Current_Dim2 - 1) = result(0, 0, Current_Dim2 - 1);
46 T3dg_equals_T3dg(iter, result, Number<Dim01>(), Number<Dim01>(),
47 Number<Current_Dim2 - 1>());
48 }
49
50 template <class A, class B, class U, int Dim01, int Dim2, char i, char j,
51 char k>
52 void
53 T3dg_equals_T3dg(A &iter, const Dg_Expr<B, U, Dim01, Dim2, i, j, k> &result,
54 const Number<1> &, const Number<1> &, const Number<1> &)
55 {
56 iter(0, 0, 0) = result(0, 0, 0);
57 }
58
59 template <class A, class T, int Tensor_Dim01, int Tensor_Dim2, int Dim01,
60 int Dim2, char i, char j, char k>
61 template <class B, class U>
62 Dg_Expr<Dg<A, Tensor_Dim01, Tensor_Dim2>, T, Dim01, Dim2, i, j, k> &
63 Dg_Expr<Dg<A, Tensor_Dim01, Tensor_Dim2>, T, Dim01, Dim2, i, j, k>::
64 operator=(const Dg_Expr<B, U, Dim01, Dim2, i, j, k> &result)
65 {
66 T3dg_equals_T3dg(iter, result, Number<Dim01>(), Number<Dim01>(),
67 Number<Dim2>());
68 return *this;
69 }
70
71 /* T3dg=T3dg_Expr(T3dg) */
72
73 template <class A, class T, int Tensor_Dim01, int Tensor_Dim2, int Dim01,
74 int Dim2, char i, char j, char k>
75 Dg_Expr<Dg<A, Tensor_Dim01, Tensor_Dim2>, T, Dim01, Dim2, i, j, k> &
76 Dg_Expr<Dg<A, Tensor_Dim01, Tensor_Dim2>, T, Dim01, Dim2, i, j, k>::
77 operator=(const Dg_Expr<Dg<A, Tensor_Dim01, Tensor_Dim2>, T, Dim01, Dim2, i,
78 j, k> &result)
79 {
80 return operator=<Dg<A, Tensor_Dim01, Tensor_Dim2>, T>(result);
81 }
82
83 /* T3dg+=T3dg */
84
85 template <bool S> struct Sign_of_T3dg_plus_equals_T3dg {};
86
87 template <> struct Sign_of_T3dg_plus_equals_T3dg<true> {
88 template <typename L, typename R> static inline void op(L &l, R &&r) {
89 l += r;
90 }
91 };
92
93 template <> struct Sign_of_T3dg_plus_equals_T3dg<false> {
94 template <typename L, typename R> static inline void op(L &l, R &&r) {
95 l -= r;
96 }
97 };
98
99 template <class A, class B, class U, int Dim01, int Dim2, char i, char j,
100 char k, int Current_Dim0, int Current_Dim1, int Current_Dim2,
101 class Op>
102 void T3dg_plus_equals_T3dg(A &iter,
103 const Dg_Expr<B, U, Dim01, Dim2, i, j, k> &result,
104 const Number<Current_Dim0> &,
105 const Number<Current_Dim1> &,
106 const Number<Current_Dim2> &, const Op &) {
107 Op::op(iter(Current_Dim0 - 1, Current_Dim1 - 1, Current_Dim2 - 1),
108 result(Current_Dim0 - 1, Current_Dim1 - 1, Current_Dim2 - 1));
109 T3dg_plus_equals_T3dg(iter, result, Number<Current_Dim0 - 1>(),
110 Number<Current_Dim1>(), Number<Current_Dim2>(), Op());
111 }
112
113 template <class A, class B, class U, int Dim01, int Dim2, char i, char j,
114 char k, int Current_Dim1, int Current_Dim2, class Op>
115 void T3dg_plus_equals_T3dg(A &iter,
116 const Dg_Expr<B, U, Dim01, Dim2, i, j, k> &result,
117 const Number<1> &, const Number<Current_Dim1> &,
118 const Number<Current_Dim2> &, const Op &) {
119 Op::op(iter(0, Current_Dim1 - 1, Current_Dim2 - 1),
120 result(0, Current_Dim1 - 1, Current_Dim2 - 1));
121 T3dg_plus_equals_T3dg(iter, result, Number<Current_Dim1 - 1>(),
122 Number<Current_Dim1 - 1>(), Number<Current_Dim2>(),
123 Op());
124 }
125
126 template <class A, class B, class U, int Dim01, int Dim2, char i, char j,
127 char k, int Current_Dim2, class Op>
128 void T3dg_plus_equals_T3dg(A &iter,
129 const Dg_Expr<B, U, Dim01, Dim2, i, j, k> &result,
130 const Number<1> &, const Number<1> &,
131 const Number<Current_Dim2> &, const Op &) {
132 Op::op(iter(0, 0, Current_Dim2 - 1), result(0, 0, Current_Dim2 - 1));
133 T3dg_plus_equals_T3dg(iter, result, Number<Dim01>(), Number<Dim01>(),
134 Number<Current_Dim2 - 1>(), Op());
135 }
136
137 template <class A, class B, class U, int Dim01, int Dim2, char i, char j,
138 char k, class Op>
139 void T3dg_plus_equals_T3dg(A &iter,
140 const Dg_Expr<B, U, Dim01, Dim2, i, j, k> &result,
141 const Number<1> &, const Number<1> &,
142 const Number<1> &, const Op &) {
143 Op::op(iter(0, 0, 0), result(0, 0, 0));
144 }
145
146 template <class A, class T, int Tensor_Dim01, int Tensor_Dim2, int Dim01,
147 int Dim2, char i, char j, char k>
148 template <class B, class U>
149 Dg_Expr<Dg<A, Tensor_Dim01, Tensor_Dim2>, T, Dim01, Dim2, i, j, k> &
150 Dg_Expr<Dg<A, Tensor_Dim01, Tensor_Dim2>, T, Dim01, Dim2, i, j, k>::
151 operator+=(const Dg_Expr<B, U, Dim01, Dim2, i, j, k> &result)
152 {
153 T3dg_plus_equals_T3dg(iter, result, Number<Dim01>(), Number<Dim01>(),
154 Number<Dim2>(),
155 Sign_of_T3dg_plus_equals_T3dg<true>());
156 return *this;
157 }
158
159 template <class A, class T, int Tensor_Dim01, int Tensor_Dim2, int Dim01,
160 int Dim2, char i, char j, char k>
161 template <class B, class U>
162 Dg_Expr<Dg<A, Tensor_Dim01, Tensor_Dim2>, T, Dim01, Dim2, i, j, k> &
163 Dg_Expr<Dg<A, Tensor_Dim01, Tensor_Dim2>, T, Dim01, Dim2, i, j, k>::
164 operator-=(const Dg_Expr<B, U, Dim01, Dim2, i, j, k> &result) {
165 T3dg_plus_equals_T3dg(iter, result, Number<Dim01>(), Number<Dim01>(),
166 Number<Dim2>(),
167 Sign_of_T3dg_plus_equals_T3dg<false>());
168 return *this;
169 }
170
171 /* T3dg+=T3dg_Expr(T3dg) */
172
173 template <class A, class T, int Tensor_Dim01, int Tensor_Dim2, int Dim01,
174 int Dim2, char i, char j, char k>
175 Dg_Expr<Dg<A, Tensor_Dim01, Tensor_Dim2>, T, Dim01, Dim2, i, j, k> &
176 Dg_Expr<Dg<A, Tensor_Dim01, Tensor_Dim2>, T, Dim01, Dim2, i, j, k>::
177 operator+=(const Dg_Expr<Dg<A, Tensor_Dim01, Tensor_Dim2>, T, Dim01, Dim2, i,
178 j, k> &result)
179 {
180 return operator+=<Dg<A, Tensor_Dim01, Tensor_Dim2>, T>(result);
181 }
182
183 template <class A, class T, int Tensor_Dim01, int Tensor_Dim2, int Dim01,
184 int Dim2, char i, char j, char k>
185 Dg_Expr<Dg<A, Tensor_Dim01, Tensor_Dim2>, T, Dim01, Dim2, i, j, k> &
186 Dg_Expr<Dg<A, Tensor_Dim01, Tensor_Dim2>, T, Dim01, Dim2, i, j, k>::
187 operator-=(const Dg_Expr<Dg<A, Tensor_Dim01, Tensor_Dim2>, T, Dim01, Dim2, i,
188 j, k> &result)
189 {
190 return operator-=<Dg<A, Tensor_Dim01, Tensor_Dim2>, T>(result);
191 }
192
193 /* T3dg=U */
194
195 template <class A, class U, int Dim01, int Dim2, int Current_Dim0,
196 int Current_Dim1, int Current_Dim2>
197 void T3dg_equals_generic(A &iter, const U &u, const Number<Current_Dim0> &,
198 const Number<Current_Dim1> &,
199 const Number<Current_Dim2> &, const Number<Dim01> &,
200 const Number<Dim2> &)
201 {
202 iter(Current_Dim0 - 1, Current_Dim1 - 1, Current_Dim2 - 1) = u;
203 T3dg_equals_generic(iter, u, Number<Current_Dim0 - 1>(),
204 Number<Current_Dim1>(), Number<Current_Dim2>(),
205 Number<Dim01>(), Number<Dim2>());
206 }
207
208 template <class A, class U, int Dim01, int Dim2, int Current_Dim1,
209 int Current_Dim2>
210 void T3dg_equals_generic(A &iter, const U &u, const Number<1> &,
211 const Number<Current_Dim1> &,
212 const Number<Current_Dim2> &, const Number<Dim01> &,
213 const Number<Dim2> &)
214 {
215 iter(0, Current_Dim1 - 1, Current_Dim2 - 1) = u;
216 T3dg_equals_generic(iter, u, Number<Current_Dim1 - 1>(),
217 Number<Current_Dim1 - 1>(), Number<Current_Dim2>(),
218 Number<Dim01>(), Number<Dim2>());
219 }
220
221 template <class A, class U, int Dim01, int Dim2, int Current_Dim2>
222 void T3dg_equals_generic(A &iter, const U &u, const Number<1> &,
223 const Number<1> &, const Number<Current_Dim2> &,
224 const Number<Dim01> &, const Number<Dim2> &)
225 {
226 iter(0, 0, Current_Dim2 - 1) = u;
227 T3dg_equals_generic(iter, u, Number<Dim01>(), Number<Dim01>(),
228 Number<Current_Dim2 - 1>(), Number<Dim01>(),
229 Number<Dim2>());
230 }
231
232 template <class A, class U, int Dim01, int Dim2>
233 void T3dg_equals_generic(A &iter, const U &u, const Number<1> &,
234 const Number<1> &, const Number<1> &,
235 const Number<Dim01> &, const Number<Dim2> &)
236 {
237 iter(0, 0, 0) = u;
238 }
239
240 template <class A, class T, int Tensor_Dim01, int Tensor_Dim2, int Dim01,
241 int Dim2, char i, char j, char k>
242 template <class U>
243 Dg_Expr<Dg<A, Tensor_Dim01, Tensor_Dim2>, T, Dim01, Dim2, i, j, k> &
244 Dg_Expr<Dg<A, Tensor_Dim01, Tensor_Dim2>, T, Dim01, Dim2, i, j, k>::
245 operator=(const U &u)
246 {
247 T3dg_equals_generic(iter, u, Number<Dim01>(), Number<Dim01>(),
248 Number<Dim2>(), Number<Dim01>(), Number<Dim2>());
249 return *this;
250 }
251
252 /* Assignment operators for the specializations to Christof. */
253
254 /* T3ch=T3dg */
255
256 /* Set operator type
257 * 0 - equal
258 * 1 - add
259 * 2 - subtract
260 */
261 template <int I> struct T3ch_equals_T3dg_Op {};
262
263 template <> struct T3ch_equals_T3dg_Op<0> {
264 template <typename L, typename R> static inline void op(L &l, R &&r) {
265 l = r;
266 }
267 };
268
269 template <> struct T3ch_equals_T3dg_Op<1> {
270 template <typename L, typename R> static inline void op(L &l, R &&r) {
271 l += r;
272 }
273 };
274
275 template <> struct T3ch_equals_T3dg_Op<2> {
276 template <typename L, typename R> static inline void op(L &l, R &&r) {
277 l -= r;
278 }
279 };
280
281 template <class A, class B, class U, int Dim12, int Dim0, char i, char j,
282 char k, int Current_Dim0, int Current_Dim1, int Current_Dim2,
283 class Op>
284 void
285 T3ch_equals_T3dg(A &iter, const Dg_Expr<B, U, Dim12, Dim0, i, j, k> &result,
286 const Number<Current_Dim0> &, const Number<Current_Dim1> &,
287 const Number<Current_Dim2> &, const Op &) {
288 Op::op(iter(Current_Dim2 - 1, Current_Dim0 - 1, Current_Dim1 - 1),
289 result(Current_Dim0 - 1, Current_Dim1 - 1, Current_Dim2 - 1));
290 T3ch_equals_T3dg(iter, result, Number<Current_Dim0 - 1>(),
291 Number<Current_Dim1>(), Number<Current_Dim2>(), Op());
292 }
293
294 template <class A, class B, class U, int Dim12, int Dim0, char i, char j,
295 char k, int Current_Dim1, int Current_Dim2, class Op>
296 void T3ch_equals_T3dg(A &iter,
297 const Dg_Expr<B, U, Dim12, Dim0, i, j, k> &result,
298 const Number<1> &, const Number<Current_Dim1> &,
299 const Number<Current_Dim2> &, const Op &) {
300 Op::op(iter(Current_Dim2 - 1, 0, Current_Dim1 - 1),
301 result(0, Current_Dim1 - 1, Current_Dim2 - 1));
302 T3ch_equals_T3dg(iter, result, Number<Current_Dim1 - 1>(),
303 Number<Current_Dim1 - 1>(), Number<Current_Dim2>(), Op());
304 }
305
306 template <class A, class B, class U, int Dim12, int Dim0, char i, char j,
307 char k, int Current_Dim2, class Op>
308 void T3ch_equals_T3dg(A &iter,
309 const Dg_Expr<B, U, Dim12, Dim0, i, j, k> &result,
310 const Number<1> &, const Number<1> &,
311 const Number<Current_Dim2> &, const Op &) {
312 Op::op(iter(Current_Dim2 - 1, 0, 0), result(0, 0, Current_Dim2 - 1));
313 T3ch_equals_T3dg(iter, result, Number<Dim12>(), Number<Dim12>(),
314 Number<Current_Dim2 - 1>(), Op());
315 }
316
317 template <class A, class B, class U, int Dim12, int Dim0, char i, char j,
318 char k, class Op>
319 void T3ch_equals_T3dg(A &iter,
320 const Dg_Expr<B, U, Dim12, Dim0, i, j, k> &result,
321 const Number<1> &, const Number<1> &, const Number<1> &,
322 const Op &) {
323 Op::op(iter(0, 0, 0), result(0, 0, 0));
324 }
325
326 template <class Tp, class T, int Tensor_Dim0, int Tensor_Dim12, int Dim12,
327 int Dim0, char i, char j, char k>
328 template <class B, class U>
329 Dg_Expr<Christof<Tp, Tensor_Dim0, Tensor_Dim12>, T, Dim12, Dim0, i, j, k> &
330 Dg_Expr<Christof<Tp, Tensor_Dim0, Tensor_Dim12>, T, Dim12, Dim0, i, j, k>::
331 operator=(const Dg_Expr<B, U, Dim12, Dim0, i, j, k> &result)
332 {
333 T3ch_equals_T3dg(iter, result, Number<Dim12>(), Number<Dim12>(),
334 Number<Dim0>(), T3ch_equals_T3dg_Op<0>());
335 return *this;
336 }
337
338 template <class Tp, class T, int Tensor_Dim0, int Tensor_Dim12, int Dim12,
339 int Dim0, char i, char j, char k>
340 template <class B, class U>
341 Dg_Expr<Christof<Tp, Tensor_Dim0, Tensor_Dim12>, T, Dim12, Dim0, i, j, k> &
342 Dg_Expr<Christof<Tp, Tensor_Dim0, Tensor_Dim12>, T, Dim12, Dim0, i, j, k>::
343 operator+=(const Dg_Expr<B, U, Dim12, Dim0, i, j, k> &result)
344 {
345 T3ch_equals_T3dg(iter, result, Number<Dim12>(), Number<Dim12>(),
346 Number<Dim0>(), T3ch_equals_T3dg_Op<1>());
347 return *this;
348 }
349
350 template <class Tp, class T, int Tensor_Dim0, int Tensor_Dim12, int Dim12,
351 int Dim0, char i, char j, char k>
352 template <class B, class U>
353 Dg_Expr<Christof<Tp, Tensor_Dim0, Tensor_Dim12>, T, Dim12, Dim0, i, j, k> &
354 Dg_Expr<Christof<Tp, Tensor_Dim0, Tensor_Dim12>, T, Dim12, Dim0, i, j, k>::
355 operator-=(const Dg_Expr<B, U, Dim12, Dim0, i, j, k> &result)
356 {
357 T3ch_equals_T3dg(iter, result, Number<Dim12>(), Number<Dim12>(),
358 Number<Dim0>(), T3ch_equals_T3dg_Op<2>());
359 return *this;
360 }
361
362 /* T3ch=T3ch_Expr(T3ch) */
363
364 template <class Tp, class T, int Tensor_Dim0, int Tensor_Dim12, int Dim12,
365 int Dim0, char i, char j, char k>
366 Dg_Expr<Christof<Tp, Tensor_Dim0, Tensor_Dim12>, T, Dim12, Dim0, i, j, k> &
367 Dg_Expr<Christof<Tp, Tensor_Dim0, Tensor_Dim12>, T, Dim12, Dim0, i, j, k>::
368 operator=(const Dg_Expr<Christof<Tp, Tensor_Dim0, Tensor_Dim12>, T, Dim12,
369 Dim0, i, j, k> &result)
370 {
371 return operator=<Christof<Tp, Tensor_Dim0, Tensor_Dim12>, T>(result);
372 }
373
374 template <class Tp, class T, int Tensor_Dim0, int Tensor_Dim12, int Dim12,
375 int Dim0, char i, char j, char k>
376 Dg_Expr<Christof<Tp, Tensor_Dim0, Tensor_Dim12>, T, Dim12, Dim0, i, j, k> &
377 Dg_Expr<Christof<Tp, Tensor_Dim0, Tensor_Dim12>, T, Dim12, Dim0, i, j, k>::
378 operator+=(const Dg_Expr<Christof<Tp, Tensor_Dim0, Tensor_Dim12>, T, Dim12,
379 Dim0, i, j, k> &result)
380 {
381 return operator+=<Christof<Tp, Tensor_Dim0, Tensor_Dim12>, T>(result);
382 }
383
384 template <class Tp, class T, int Tensor_Dim0, int Tensor_Dim12, int Dim12,
385 int Dim0, char i, char j, char k>
386 Dg_Expr<Christof<Tp, Tensor_Dim0, Tensor_Dim12>, T, Dim12, Dim0, i, j, k> &
387 Dg_Expr<Christof<Tp, Tensor_Dim0, Tensor_Dim12>, T, Dim12, Dim0, i, j, k>::
388 operator-=(const Dg_Expr<Christof<Tp, Tensor_Dim0, Tensor_Dim12>, T, Dim12,
389 Dim0, i, j, k> &result)
390 {
391 return operator-=<Christof<Tp, Tensor_Dim0, Tensor_Dim12>, T>(result);
392 }
393
394 /* T3ch=U */
395
396 template <class A, class U, int Dim12, int Dim0, int Current_Dim0,
397 int Current_Dim1, int Current_Dim2>
398 void T3ch_equals_generic(A &iter, const U &u, const Number<Current_Dim0> &,
399 const Number<Current_Dim1> &,
400 const Number<Current_Dim2> &, const Number<Dim12> &,
401 const Number<Dim0> &)
402 {
403 iter(Current_Dim2 - 1, Current_Dim0 - 1, Current_Dim1 - 1) = u;
404 T3ch_equals_generic(iter, u, Number<Current_Dim0 - 1>(),
405 Number<Current_Dim1>(), Number<Current_Dim2>(),
406 Number<Dim12>(), Number<Dim0>());
407 }
408
409 template <class A, class U, int Dim12, int Dim0, int Current_Dim1,
410 int Current_Dim2>
411 void T3ch_equals_generic(A &iter, const U &u, const Number<1> &,
412 const Number<Current_Dim1> &,
413 const Number<Current_Dim2> &, const Number<Dim12> &,
414 const Number<Dim0> &)
415 {
416 iter(Current_Dim2 - 1, 0, Current_Dim1 - 1) = u;
417 T3ch_equals_generic(iter, u, Number<Current_Dim1 - 1>(),
418 Number<Current_Dim1 - 1>(), Number<Current_Dim2>(),
419 Number<Dim12>(), Number<Dim0>());
420 }
421
422 template <class A, class U, int Dim12, int Dim0, int Current_Dim2>
423 void T3ch_equals_generic(A &iter, const U &u, const Number<1> &,
424 const Number<1> &, const Number<Current_Dim2> &,
425 const Number<Dim12> &, const Number<Dim0> &)
426 {
427 iter(Current_Dim2 - 1, 0, 0) = u;
428 T3ch_equals_generic(iter, u, Number<Dim12>(), Number<Dim12>(),
429 Number<Current_Dim2 - 1>(), Number<Dim12>(),
430 Number<Dim0>());
431 }
432
433 template <class A, class U, int Dim12, int Dim0>
434 void T3ch_equals_generic(A &iter, const U &u, const Number<1> &,
435 const Number<1> &, const Number<1> &,
436 const Number<Dim12> &, const Number<Dim0> &)
437 {
438 iter(0, 0, 0) = u;
439 }
440
441 template <class A, class T, int Tensor_Dim0, int Tensor_Dim12, int Dim12,
442 int Dim0, char i, char j, char k>
443 template <class U>
444 Dg_Expr<Christof<A, Tensor_Dim0, Tensor_Dim12>, T, Dim12, Dim0, i, j, k> &
445 Dg_Expr<Christof<A, Tensor_Dim0, Tensor_Dim12>, T, Dim12, Dim0, i, j, k>::
446 operator=(const U &u)
447 {
448 T3ch_equals_generic(iter, u, Number<Dim12>(), Number<Dim12>(),
449 Number<Dim0>(), Number<Dim12>(), Number<Dim0>());
450 return *this;
451 }
452
453 /* Assignment operators for the specializations to Ddg_number_rhs_0. */
454
455 /* T4ddgrhs0=T3dg */
456
457 template <class A, class B, class U, int Dim23, int Dim1, char i, char j,
458 char k, int Current_Dim0, int Current_Dim1, int Current_Dim2, int N>
459 void T4ddgrhs0_equals_T3dg(A &iter,
460 const Dg_Expr<B, U, Dim23, Dim1, i, j, k> &result,
461 const Number<Current_Dim0> &,
462 const Number<Current_Dim1> &,
463 const Number<Current_Dim2> &, const Number<N> &)
464 {
465 iter(N, Current_Dim2 - 1, Current_Dim0 - 1, Current_Dim1 - 1)
466 = result(Current_Dim0 - 1, Current_Dim1 - 1, Current_Dim2 - 1);
467 T4ddgrhs0_equals_T3dg(iter, result, Number<Current_Dim0 - 1>(),
468 Number<Current_Dim1>(), Number<Current_Dim2>(),
469 Number<N>());
470 }
471
472 template <class A, class B, class U, int Dim23, int Dim1, char i, char j,
473 char k, int Current_Dim1, int Current_Dim2, int N>
474 void T4ddgrhs0_equals_T3dg(A &iter,
475 const Dg_Expr<B, U, Dim23, Dim1, i, j, k> &result,
476 const Number<1> &, const Number<Current_Dim1> &,
477 const Number<Current_Dim2> &, const Number<N> &)
478 {
479 iter(N, Current_Dim2 - 1, 0, Current_Dim1 - 1)
480 = result(0, Current_Dim1 - 1, Current_Dim2 - 1);
481 T4ddgrhs0_equals_T3dg(iter, result, Number<Current_Dim1 - 1>(),
482 Number<Current_Dim1 - 1>(), Number<Current_Dim2>(),
483 Number<N>());
484 }
485
486 template <class A, class B, class U, int Dim23, int Dim1, char i, char j,
487 char k, int Current_Dim2, int N>
488 void T4ddgrhs0_equals_T3dg(A &iter,
489 const Dg_Expr<B, U, Dim23, Dim1, i, j, k> &result,
490 const Number<1> &, const Number<1> &,
491 const Number<Current_Dim2> &, const Number<N> &)
492 {
493 iter(N, Current_Dim2 - 1, 0, 0) = result(0, 0, Current_Dim2 - 1);
494 T4ddgrhs0_equals_T3dg(iter, result, Number<Dim23>(), Number<Dim23>(),
495 Number<Current_Dim2 - 1>(), Number<N>());
496 }
497
498 template <class A, class B, class U, int Dim23, int Dim1, char i, char j,
499 char k, int N>
500 void T4ddgrhs0_equals_T3dg(A &iter,
501 const Dg_Expr<B, U, Dim23, Dim1, i, j, k> &result,
502 const Number<1> &, const Number<1> &,
503 const Number<1> &, const Number<N> &)
504 {
505 iter(N, 0, 0, 0) = result(0, 0, 0);
506 }
507
508 template <class A, class T, int Dim23, int Dim1, char i, char j, char k,
509 int N>
510 template <class B, class U>
511 Dg_Expr<Ddg_number_rhs_0<A, T, N>, T, Dim23, Dim1, i, j, k> &
512 Dg_Expr<Ddg_number_rhs_0<A, T, N>, T, Dim23, Dim1, i, j, k>::
513 operator=(const Dg_Expr<B, U, Dim23, Dim1, i, j, k> &result)
514 {
515 T4ddgrhs0_equals_T3dg(iter, result, Number<Dim23>(), Number<Dim23>(),
516 Number<Dim1>(), Number<N>());
517 return *this;
518 }
519
520 /* T4ddgrhs0=T4ddgrhs0 */
521
522 template <class A, class T, int Dim23, int Dim1, char i, char j, char k,
523 int N>
524 Dg_Expr<Ddg_number_rhs_0<A, T, N>, T, Dim23, Dim1, i, j, k> &
525 Dg_Expr<Ddg_number_rhs_0<A, T, N>, T, Dim23, Dim1, i, j, k>::operator=(
526 const Dg_Expr<Ddg_number_rhs_0<A, T, N>, T, Dim23, Dim1, i, j, k> &result)
527 {
528 return operator=<Ddg_number_rhs_0<A, T, N>, T>(result);
529 }
530}
L
static Index< 'L', 3 > L
Definition: BasicFeTools.hpp:95
FTensor::Dg_Expr
Definition: Dg_Expr.hpp:26
i
FTensor::Index< 'i', SPACE_DIM > i
Definition: hcurl_divergence_operator_2d.cpp:27
l
FTensor::Index< 'l', 3 > l
Definition: matrix_function.cpp:21
j
FTensor::Index< 'j', 3 > j
Definition: matrix_function.cpp:19
k
FTensor::Index< 'k', 3 > k
Definition: matrix_function.cpp:20
T
const double T
Definition: mixed_reac_diff.cpp:158
FTensor
Tensors class implemented by Walter Landry.
Definition: FTensor.hpp:51
FTensor::T3dg_equals_generic
void T3dg_equals_generic(A &iter, const U &u, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &, const Number< Dim01 > &, const Number< Dim2 > &)
Definition: Dg_Expr_equals.hpp:197
FTensor::T3dg_plus_equals_T3dg
void T3dg_plus_equals_T3dg(A &iter, const Dg_Expr< B, U, Dim01, Dim2, i, j, k > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &, const Op &)
Definition: Dg_Expr_equals.hpp:102
FTensor::T3ch_equals_generic
void T3ch_equals_generic(A &iter, const U &u, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &, const Number< Dim12 > &, const Number< Dim0 > &)
Definition: Dg_Expr_equals.hpp:398
FTensor::T4ddgrhs0_equals_T3dg
void T4ddgrhs0_equals_T3dg(A &iter, const Dg_Expr< B, U, Dim23, Dim1, i, j, k > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &, const Number< N > &)
Definition: Dg_Expr_equals.hpp:459
FTensor::T3dg_equals_T3dg
void T3dg_equals_T3dg(A &iter, const Dg_Expr< B, U, Dim01, Dim2, i, j, k > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
Definition: Dg_Expr_equals.hpp:15
FTensor::T3ch_equals_T3dg
void T3ch_equals_T3dg(A &iter, const Dg_Expr< B, U, Dim12, Dim0, i, j, k > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &, const Op &)
Definition: Dg_Expr_equals.hpp:285
A
constexpr AssemblyType A
Definition: operators_tests.cpp:30
N
const int N
Definition: speed_test.cpp:3
FTensor::Sign_of_T3dg_plus_equals_T3dg< false >::op
static void op(L &l, R &&r)
Definition: Dg_Expr_equals.hpp:94
FTensor::Sign_of_T3dg_plus_equals_T3dg< true >::op
static void op(L &l, R &&r)
Definition: Dg_Expr_equals.hpp:88
FTensor::Sign_of_T3dg_plus_equals_T3dg
Definition: Dg_Expr_equals.hpp:85
FTensor::T3ch_equals_T3dg_Op< 0 >::op
static void op(L &l, R &&r)
Definition: Dg_Expr_equals.hpp:264
FTensor::T3ch_equals_T3dg_Op< 1 >::op
static void op(L &l, R &&r)
Definition: Dg_Expr_equals.hpp:270
FTensor::T3ch_equals_T3dg_Op< 2 >::op
static void op(L &l, R &&r)
Definition: Dg_Expr_equals.hpp:276
FTensor::T3ch_equals_T3dg_Op
Definition: Dg_Expr_equals.hpp:261
Generated by Doxygen 1.9.5 and hosted at University of Glasgow