QMCPACK
OhmmsMatrixOperators.h
Go to the documentation of this file.
1 //////////////////////////////////////////////////////////////////////////////////////
2 // This file is distributed under the University of Illinois/NCSA Open Source License.
3 // See LICENSE file in top directory for details.
4 //
5 // Copyright (c) 2016 Jeongnim Kim and QMCPACK developers.
6 //
7 // File developed by: Jeremy McMinnis, jmcminis@gmail.com, University of Illinois at Urbana-Champaign
8 //
9 // File created by: Jeongnim Kim, jeongnim.kim@gmail.com, University of Illinois at Urbana-Champaign
10 //////////////////////////////////////////////////////////////////////////////////////
11 
12 #ifndef OHMMS_MATRIXOPERATOR_H
13 #define OHMMS_MATRIXOPERATOR_H
14 
15 ///////////////////////////////////////////////////////////////////////////////
16 //
17 // WARNING: THIS FILE WAS GENERATED AUTOMATICALLY!
18 // YOU SHOULD MODIFY THE INPUT FILES INSTEAD OF CHANGING THIS FILE DIRECTLY!
19 //
20 // THE FOLLOWING INPUT FILES WERE USED TO MAKE THIS FILE:
21 //
22 // MakeOperators
23 // matrixOps.in
24 // MatrixDefs.in
25 ///////////////////////////////////////////////////////////////////////////////
26 
27 namespace qmcplusplus
28 {
29 template<class T1, class C1>
30 inline typename MakeReturn<UnaryNode<OpUnaryMinus, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t>>::Expression_t
31  operator-(const Matrix<T1, C1>& l)
32 {
33  using Tree_t = UnaryNode<OpUnaryMinus, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t>;
34  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Matrix<T1, C1>>::make(l)));
35 }
36 
37 template<class T1, class C1>
38 inline typename MakeReturn<UnaryNode<OpUnaryPlus, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t>>::Expression_t operator+(
39  const Matrix<T1, C1>& l)
40 {
41  using Tree_t = UnaryNode<OpUnaryPlus, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t>;
42  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Matrix<T1, C1>>::make(l)));
43 }
44 
45 template<class T1, class C1>
46 inline typename MakeReturn<UnaryNode<OpBitwiseNot, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t>>::Expression_t
47  operator~(const Matrix<T1, C1>& l)
48 {
49  using Tree_t = UnaryNode<OpBitwiseNot, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t>;
50  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Matrix<T1, C1>>::make(l)));
51 }
52 
53 template<class T1, class C1>
54 inline typename MakeReturn<UnaryNode<OpIdentity, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t>>::Expression_t
55  PETE_identity(const Matrix<T1, C1>& l)
56 {
57  using Tree_t = UnaryNode<OpIdentity, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t>;
58  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Matrix<T1, C1>>::make(l)));
59 }
60 
61 template<class T1, class T2, class C2>
62 inline typename MakeReturn<UnaryNode<OpCast<T1>, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>>::Expression_t peteCast(
63  const T1&,
64  const Matrix<T2, C2>& l)
65 {
66  using Tree_t = UnaryNode<OpCast<T1>, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>;
67  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Matrix<T2, C2>>::make(l)));
68 }
69 
70 template<class T1, class C1, class T2, class C2>
71 inline typename MakeReturn<
72  BinaryNode<OpAdd, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>>::
73  Expression_t
74  operator+(const Matrix<T1, C1>& l, const Matrix<T2, C2>& r)
75 {
76  typedef BinaryNode<OpAdd, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>
77  Tree_t;
78  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Matrix<T1, C1>>::make(l), CreateLeaf<Matrix<T2, C2>>::make(r)));
79 }
80 
81 template<class T1, class C1, class T2, class C2>
82 inline typename MakeReturn<
83  BinaryNode<OpSubtract, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>>::
84  Expression_t
85  operator-(const Matrix<T1, C1>& l, const Matrix<T2, C2>& r)
86 {
87  typedef BinaryNode<OpSubtract, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t,
88  typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>
89  Tree_t;
90  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Matrix<T1, C1>>::make(l), CreateLeaf<Matrix<T2, C2>>::make(r)));
91 }
92 
93 /////////////////////////////////////////////////////////
94 template<class T1, class C1, class T2, class C2>
95 inline typename MakeReturn<
96  BinaryNode<OpMultiply, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>>::
97  Expression_t
98  operator*(const Matrix<T1, C1>& l, const Matrix<T2, C2>& r)
99 {
100  typedef BinaryNode<OpMultiply, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t,
101  typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>
102  Tree_t;
103  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Matrix<T1, C1>>::make(l), CreateLeaf<Matrix<T2, C2>>::make(r)));
104 }
105 ////////////////////////////////////////////////////////
106 template<class T1, class C1, class T2, class C2>
107 inline typename MakeReturn<
108  BinaryNode<OpMod, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>>::
109  Expression_t
110  operator%(const Matrix<T1, C1>& l, const Matrix<T2, C2>& r)
111 {
112  typedef BinaryNode<OpMod, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>
113  Tree_t;
114  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Matrix<T1, C1>>::make(l), CreateLeaf<Matrix<T2, C2>>::make(r)));
115 }
116 
117 template<class T1, class C1, class T2, class C2>
118 inline typename MakeReturn<BinaryNode<OpBitwiseAnd,
119  typename CreateLeaf<Matrix<T1, C1>>::Leaf_t,
120  typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>>::Expression_t
121  operator&(const Matrix<T1, C1>& l, const Matrix<T2, C2>& r)
122 {
123  typedef BinaryNode<OpBitwiseAnd, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t,
124  typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>
125  Tree_t;
126  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Matrix<T1, C1>>::make(l), CreateLeaf<Matrix<T2, C2>>::make(r)));
127 }
128 
129 template<class T1, class C1, class T2, class C2>
130 inline typename MakeReturn<
131  BinaryNode<OpBitwiseOr, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>>::
132  Expression_t
133  operator|(const Matrix<T1, C1>& l, const Matrix<T2, C2>& r)
134 {
135  typedef BinaryNode<OpBitwiseOr, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t,
136  typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>
137  Tree_t;
138  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Matrix<T1, C1>>::make(l), CreateLeaf<Matrix<T2, C2>>::make(r)));
139 }
140 
141 template<class T1, class C1, class T2, class C2>
142 inline typename MakeReturn<BinaryNode<OpBitwiseXor,
143  typename CreateLeaf<Matrix<T1, C1>>::Leaf_t,
144  typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>>::Expression_t
145  operator^(const Matrix<T1, C1>& l, const Matrix<T2, C2>& r)
146 {
147  typedef BinaryNode<OpBitwiseXor, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t,
148  typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>
149  Tree_t;
150  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Matrix<T1, C1>>::make(l), CreateLeaf<Matrix<T2, C2>>::make(r)));
151 }
152 
153 template<class T1, class C1, class T2>
154 inline typename MakeReturn<
155  BinaryNode<OpAdd, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
156  Expression_t
157  operator+(const Matrix<T1, C1>& l, const Expression<T2>& r)
158 {
159  typedef BinaryNode<OpAdd, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
160  Tree_t;
161  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Matrix<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
162 }
163 
164 template<class T1, class C1, class T2>
165 inline typename MakeReturn<
166  BinaryNode<OpSubtract, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
167  Expression_t
168  operator-(const Matrix<T1, C1>& l, const Expression<T2>& r)
169 {
170  typedef BinaryNode<OpSubtract, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t,
171  typename CreateLeaf<Expression<T2>>::Leaf_t>
172  Tree_t;
173  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Matrix<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
174 }
175 
176 template<class T1, class C1, class T2>
177 inline typename MakeReturn<
178  BinaryNode<OpMultiply, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
179  Expression_t
180  operator*(const Matrix<T1, C1>& l, const Expression<T2>& r)
181 {
182  typedef BinaryNode<OpMultiply, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t,
183  typename CreateLeaf<Expression<T2>>::Leaf_t>
184  Tree_t;
185  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Matrix<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
186 }
187 
188 template<class T1, class C1, class T2>
189 inline typename MakeReturn<
190  BinaryNode<OpMod, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
191  Expression_t
192  operator%(const Matrix<T1, C1>& l, const Expression<T2>& r)
193 {
194  typedef BinaryNode<OpMod, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
195  Tree_t;
196  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Matrix<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
197 }
198 
199 template<class T1, class C1, class T2>
200 inline typename MakeReturn<BinaryNode<OpBitwiseAnd,
201  typename CreateLeaf<Matrix<T1, C1>>::Leaf_t,
202  typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
203  operator&(const Matrix<T1, C1>& l, const Expression<T2>& r)
204 {
205  typedef BinaryNode<OpBitwiseAnd, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t,
206  typename CreateLeaf<Expression<T2>>::Leaf_t>
207  Tree_t;
208  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Matrix<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
209 }
210 
211 template<class T1, class C1, class T2>
212 inline typename MakeReturn<
213  BinaryNode<OpBitwiseOr, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
214  Expression_t
215  operator|(const Matrix<T1, C1>& l, const Expression<T2>& r)
216 {
217  typedef BinaryNode<OpBitwiseOr, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t,
218  typename CreateLeaf<Expression<T2>>::Leaf_t>
219  Tree_t;
220  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Matrix<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
221 }
222 
223 template<class T1, class C1, class T2>
224 inline typename MakeReturn<BinaryNode<OpBitwiseXor,
225  typename CreateLeaf<Matrix<T1, C1>>::Leaf_t,
226  typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
227  operator^(const Matrix<T1, C1>& l, const Expression<T2>& r)
228 {
229  typedef BinaryNode<OpBitwiseXor, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t,
230  typename CreateLeaf<Expression<T2>>::Leaf_t>
231  Tree_t;
232  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Matrix<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
233 }
234 
235 template<class T1, class T2, class C2>
236 inline typename MakeReturn<
237  BinaryNode<OpAdd, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>>::
238  Expression_t
239  operator+(const Expression<T1>& l, const Matrix<T2, C2>& r)
240 {
241  typedef BinaryNode<OpAdd, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>
242  Tree_t;
243  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Matrix<T2, C2>>::make(r)));
244 }
245 
246 template<class T1, class T2, class C2>
247 inline typename MakeReturn<
248  BinaryNode<OpSubtract, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>>::
249  Expression_t
250  operator-(const Expression<T1>& l, const Matrix<T2, C2>& r)
251 {
252  typedef BinaryNode<OpSubtract, typename CreateLeaf<Expression<T1>>::Leaf_t,
253  typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>
254  Tree_t;
255  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Matrix<T2, C2>>::make(r)));
256 }
257 
258 template<class T1, class T2, class C2>
259 inline typename MakeReturn<
260  BinaryNode<OpMultiply, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>>::
261  Expression_t
262  operator*(const Expression<T1>& l, const Matrix<T2, C2>& r)
263 {
264  typedef BinaryNode<OpMultiply, typename CreateLeaf<Expression<T1>>::Leaf_t,
265  typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>
266  Tree_t;
267  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Matrix<T2, C2>>::make(r)));
268 }
269 
270 template<class T1, class T2, class C2>
271 inline typename MakeReturn<
272  BinaryNode<OpMod, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>>::
273  Expression_t
274  operator%(const Expression<T1>& l, const Matrix<T2, C2>& r)
275 {
276  typedef BinaryNode<OpMod, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>
277  Tree_t;
278  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Matrix<T2, C2>>::make(r)));
279 }
280 
281 template<class T1, class T2, class C2>
282 inline typename MakeReturn<BinaryNode<OpBitwiseAnd,
283  typename CreateLeaf<Expression<T1>>::Leaf_t,
284  typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>>::Expression_t
285  operator&(const Expression<T1>& l, const Matrix<T2, C2>& r)
286 {
287  typedef BinaryNode<OpBitwiseAnd, typename CreateLeaf<Expression<T1>>::Leaf_t,
288  typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>
289  Tree_t;
290  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Matrix<T2, C2>>::make(r)));
291 }
292 
293 template<class T1, class T2, class C2>
294 inline typename MakeReturn<
295  BinaryNode<OpBitwiseOr, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>>::
296  Expression_t
297  operator|(const Expression<T1>& l, const Matrix<T2, C2>& r)
298 {
299  typedef BinaryNode<OpBitwiseOr, typename CreateLeaf<Expression<T1>>::Leaf_t,
300  typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>
301  Tree_t;
302  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Matrix<T2, C2>>::make(r)));
303 }
304 
305 template<class T1, class T2, class C2>
306 inline typename MakeReturn<BinaryNode<OpBitwiseXor,
307  typename CreateLeaf<Expression<T1>>::Leaf_t,
308  typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>>::Expression_t
309  operator^(const Expression<T1>& l, const Matrix<T2, C2>& r)
310 {
311  typedef BinaryNode<OpBitwiseXor, typename CreateLeaf<Expression<T1>>::Leaf_t,
312  typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>
313  Tree_t;
314  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Matrix<T2, C2>>::make(r)));
315 }
316 
317 template<class T1, class C1, class T2>
318 inline typename MakeReturn<
319  BinaryNode<OpAdd, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
320  operator+(const Matrix<T1, C1>& l, const T2& r)
321 {
322  using Tree_t = BinaryNode<OpAdd, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
323  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Matrix<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
324 }
325 
326 template<class T1, class C1, class T2>
327 inline typename MakeReturn<
328  BinaryNode<OpSubtract, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
329  operator-(const Matrix<T1, C1>& l, const T2& r)
330 {
331  using Tree_t = BinaryNode<OpSubtract, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
332  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Matrix<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
333 }
334 
335 template<class T1, class C1, class T2>
336 inline typename MakeReturn<
337  BinaryNode<OpMultiply, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
338  operator*(const Matrix<T1, C1>& l, const T2& r)
339 {
340  using Tree_t = BinaryNode<OpMultiply, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
341  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Matrix<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
342 }
343 
344 template<class T1, class C1, class T2>
345 inline typename MakeReturn<
346  BinaryNode<OpMod, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
347  operator%(const Matrix<T1, C1>& l, const T2& r)
348 {
349  using Tree_t = BinaryNode<OpMod, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
350  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Matrix<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
351 }
352 
353 template<class T1, class C1, class T2>
354 inline typename MakeReturn<
355  BinaryNode<OpBitwiseAnd, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::
356  Expression_t
357  operator&(const Matrix<T1, C1>& l, const T2& r)
358 {
359  using Tree_t = BinaryNode<OpBitwiseAnd, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
360  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Matrix<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
361 }
362 
363 template<class T1, class C1, class T2>
364 inline typename MakeReturn<
365  BinaryNode<OpBitwiseOr, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
366  operator|(const Matrix<T1, C1>& l, const T2& r)
367 {
368  using Tree_t = BinaryNode<OpBitwiseOr, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
369  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Matrix<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
370 }
371 
372 template<class T1, class C1, class T2>
373 inline typename MakeReturn<
374  BinaryNode<OpBitwiseXor, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::
375  Expression_t
376  operator^(const Matrix<T1, C1>& l, const T2& r)
377 {
378  using Tree_t = BinaryNode<OpBitwiseXor, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
379  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Matrix<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
380 }
381 
382 template<class T1, class T2, class C2>
383 inline typename MakeReturn<
384  BinaryNode<OpAdd, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>>::Expression_t
385  operator+(const T1& l, const Matrix<T2, C2>& r)
386 {
387  using Tree_t = BinaryNode<OpAdd, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>;
388  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Matrix<T2, C2>>::make(r)));
389 }
390 
391 template<class T1, class T2, class C2>
392 inline typename MakeReturn<
393  BinaryNode<OpSubtract, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>>::Expression_t
394  operator-(const T1& l, const Matrix<T2, C2>& r)
395 {
396  using Tree_t = BinaryNode<OpSubtract, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>;
397  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Matrix<T2, C2>>::make(r)));
398 }
399 
400 template<class T1, class T2, class C2>
401 inline typename MakeReturn<
402  BinaryNode<OpMultiply, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>>::Expression_t
403  operator*(const T1& l, const Matrix<T2, C2>& r)
404 {
405  using Tree_t = BinaryNode<OpMultiply, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>;
406  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Matrix<T2, C2>>::make(r)));
407 }
408 
409 template<class T1, class T2, class C2>
410 inline typename MakeReturn<
411  BinaryNode<OpMod, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>>::Expression_t
412  operator%(const T1& l, const Matrix<T2, C2>& r)
413 {
414  using Tree_t = BinaryNode<OpMod, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>;
415  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Matrix<T2, C2>>::make(r)));
416 }
417 
418 template<class T1, class T2, class C2>
419 inline typename MakeReturn<
420  BinaryNode<OpBitwiseAnd, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>>::
421  Expression_t
422  operator&(const T1& l, const Matrix<T2, C2>& r)
423 {
424  using Tree_t = BinaryNode<OpBitwiseAnd, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>;
425  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Matrix<T2, C2>>::make(r)));
426 }
427 
428 template<class T1, class T2, class C2>
429 inline typename MakeReturn<
430  BinaryNode<OpBitwiseOr, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>>::Expression_t
431  operator|(const T1& l, const Matrix<T2, C2>& r)
432 {
433  using Tree_t = BinaryNode<OpBitwiseOr, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>;
434  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Matrix<T2, C2>>::make(r)));
435 }
436 
437 template<class T1, class T2, class C2>
438 inline typename MakeReturn<
439  BinaryNode<OpBitwiseXor, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>>::
440  Expression_t
441  operator^(const T1& l, const Matrix<T2, C2>& r)
442 {
443  using Tree_t = BinaryNode<OpBitwiseXor, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Matrix<T2, C2>>::Leaf_t>;
444  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Matrix<T2, C2>>::make(r)));
445 }
446 #ifdef PETE_ALLOW_SCALAR_SHIFT
447 #endif // PETE_ALLOW_SCALAR_SHIFT
448 
449 template<class T1, class C1, class T2, class T3>
450 inline typename MakeReturn<TrinaryNode<FnWhere,
451  typename CreateLeaf<Matrix<T1, C1>>::Leaf_t,
452  typename CreateLeaf<T2>::Leaf_t,
453  typename CreateLeaf<T3>::Leaf_t>>::Expression_t
454  where(const Matrix<T1, C1>& c, const T2& t, const T3& f)
455 {
456  typedef TrinaryNode<FnWhere, typename CreateLeaf<Matrix<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t,
457  typename CreateLeaf<T3>::Leaf_t>
458  Tree_t;
459  return MakeReturn<Tree_t>::make(
460  Tree_t(CreateLeaf<Matrix<T1, C1>>::make(c), CreateLeaf<T2>::make(t), CreateLeaf<T3>::make(f)));
461 }
462 #ifndef PETE_EXPRESSION_OPERATORS
463 #define PETE_EXPRESSION_OPERATORS
464 
465 template<class T1>
466 inline typename MakeReturn<UnaryNode<OpUnaryMinus, typename CreateLeaf<Expression<T1>>::Leaf_t>>::Expression_t
467  operator-(const Expression<T1>& l)
468 {
469  using Tree_t = UnaryNode<OpUnaryMinus, typename CreateLeaf<Expression<T1>>::Leaf_t>;
470  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l)));
471 }
472 
473 template<class T1>
474 inline typename MakeReturn<UnaryNode<OpUnaryPlus, typename CreateLeaf<Expression<T1>>::Leaf_t>>::Expression_t operator+(
475  const Expression<T1>& l)
476 {
477  using Tree_t = UnaryNode<OpUnaryPlus, typename CreateLeaf<Expression<T1>>::Leaf_t>;
478  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l)));
479 }
480 
481 template<class T1>
482 inline typename MakeReturn<UnaryNode<OpBitwiseNot, typename CreateLeaf<Expression<T1>>::Leaf_t>>::Expression_t
483  operator~(const Expression<T1>& l)
484 {
485  using Tree_t = UnaryNode<OpBitwiseNot, typename CreateLeaf<Expression<T1>>::Leaf_t>;
486  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l)));
487 }
488 
489 template<class T1>
490 inline typename MakeReturn<UnaryNode<OpIdentity, typename CreateLeaf<Expression<T1>>::Leaf_t>>::Expression_t
491  PETE_identity(const Expression<T1>& l)
492 {
493  using Tree_t = UnaryNode<OpIdentity, typename CreateLeaf<Expression<T1>>::Leaf_t>;
494  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l)));
495 }
496 
497 template<class T1, class T2>
498 inline typename MakeReturn<UnaryNode<OpCast<T1>, typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t peteCast(
499  const T1&,
500  const Expression<T2>& l)
501 {
502  using Tree_t = UnaryNode<OpCast<T1>, typename CreateLeaf<Expression<T2>>::Leaf_t>;
503  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T2>>::make(l)));
504 }
505 
506 template<class T1, class T2>
507 inline typename MakeReturn<
508  BinaryNode<OpAdd, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
509  Expression_t
510  operator+(const Expression<T1>& l, const Expression<T2>& r)
511 {
512  typedef BinaryNode<OpAdd, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
513  Tree_t;
514  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
515 }
516 
517 template<class T1, class T2>
518 inline typename MakeReturn<
519  BinaryNode<OpSubtract, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
520  Expression_t
521  operator-(const Expression<T1>& l, const Expression<T2>& r)
522 {
523  typedef BinaryNode<OpSubtract, typename CreateLeaf<Expression<T1>>::Leaf_t,
524  typename CreateLeaf<Expression<T2>>::Leaf_t>
525  Tree_t;
526  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
527 }
528 
529 template<class T1, class T2>
530 inline typename MakeReturn<
531  BinaryNode<OpMultiply, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
532  Expression_t
533  operator*(const Expression<T1>& l, const Expression<T2>& r)
534 {
535  typedef BinaryNode<OpMultiply, typename CreateLeaf<Expression<T1>>::Leaf_t,
536  typename CreateLeaf<Expression<T2>>::Leaf_t>
537  Tree_t;
538  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
539 }
540 
541 template<class T1, class T2>
542 inline typename MakeReturn<
543  BinaryNode<OpMod, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
544  Expression_t
545  operator%(const Expression<T1>& l, const Expression<T2>& r)
546 {
547  typedef BinaryNode<OpMod, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
548  Tree_t;
549  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
550 }
551 
552 template<class T1, class T2>
553 inline typename MakeReturn<BinaryNode<OpBitwiseAnd,
554  typename CreateLeaf<Expression<T1>>::Leaf_t,
555  typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
556  operator&(const Expression<T1>& l, const Expression<T2>& r)
557 {
558  typedef BinaryNode<OpBitwiseAnd, typename CreateLeaf<Expression<T1>>::Leaf_t,
559  typename CreateLeaf<Expression<T2>>::Leaf_t>
560  Tree_t;
561  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
562 }
563 
564 template<class T1, class T2>
565 inline typename MakeReturn<
566  BinaryNode<OpBitwiseOr, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
567  Expression_t
568  operator|(const Expression<T1>& l, const Expression<T2>& r)
569 {
570  typedef BinaryNode<OpBitwiseOr, typename CreateLeaf<Expression<T1>>::Leaf_t,
571  typename CreateLeaf<Expression<T2>>::Leaf_t>
572  Tree_t;
573  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
574 }
575 
576 template<class T1, class T2>
577 inline typename MakeReturn<BinaryNode<OpBitwiseXor,
578  typename CreateLeaf<Expression<T1>>::Leaf_t,
579  typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
580  operator^(const Expression<T1>& l, const Expression<T2>& r)
581 {
582  typedef BinaryNode<OpBitwiseXor, typename CreateLeaf<Expression<T1>>::Leaf_t,
583  typename CreateLeaf<Expression<T2>>::Leaf_t>
584  Tree_t;
585  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
586 }
587 
588 template<class T1, class T2>
589 inline typename MakeReturn<
590  BinaryNode<OpAdd, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
591  operator+(const Expression<T1>& l, const T2& r)
592 {
593  using Tree_t = BinaryNode<OpAdd, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
594  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
595 }
596 
597 template<class T1, class T2>
598 inline typename MakeReturn<
599  BinaryNode<OpSubtract, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
600  operator-(const Expression<T1>& l, const T2& r)
601 {
602  using Tree_t = BinaryNode<OpSubtract, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
603  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
604 }
605 
606 template<class T1, class T2>
607 inline typename MakeReturn<
608  BinaryNode<OpMultiply, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
609  operator*(const Expression<T1>& l, const T2& r)
610 {
611  using Tree_t = BinaryNode<OpMultiply, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
612  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
613 }
614 
615 template<class T1, class T2>
616 inline typename MakeReturn<
617  BinaryNode<OpMod, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
618  operator%(const Expression<T1>& l, const T2& r)
619 {
620  using Tree_t = BinaryNode<OpMod, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
621  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
622 }
623 
624 template<class T1, class T2>
625 inline typename MakeReturn<
626  BinaryNode<OpBitwiseAnd, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::
627  Expression_t
628  operator&(const Expression<T1>& l, const T2& r)
629 {
630  using Tree_t = BinaryNode<OpBitwiseAnd, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
631  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
632 }
633 
634 template<class T1, class T2>
635 inline typename MakeReturn<
636  BinaryNode<OpBitwiseOr, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
637  operator|(const Expression<T1>& l, const T2& r)
638 {
639  using Tree_t = BinaryNode<OpBitwiseOr, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
640  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
641 }
642 
643 template<class T1, class T2>
644 inline typename MakeReturn<
645  BinaryNode<OpBitwiseXor, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::
646  Expression_t
647  operator^(const Expression<T1>& l, const T2& r)
648 {
649  using Tree_t = BinaryNode<OpBitwiseXor, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
650  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
651 }
652 
653 template<class T1, class T2>
654 inline typename MakeReturn<
655  BinaryNode<OpAdd, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
656  operator+(const T1& l, const Expression<T2>& r)
657 {
658  using Tree_t = BinaryNode<OpAdd, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
659  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
660 }
661 
662 template<class T1, class T2>
663 inline typename MakeReturn<
664  BinaryNode<OpSubtract, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
665  operator-(const T1& l, const Expression<T2>& r)
666 {
667  using Tree_t = BinaryNode<OpSubtract, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
668  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
669 }
670 
671 template<class T1, class T2>
672 inline typename MakeReturn<
673  BinaryNode<OpMultiply, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
674  operator*(const T1& l, const Expression<T2>& r)
675 {
676  using Tree_t = BinaryNode<OpMultiply, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
677  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
678 }
679 
680 template<class T1, class T2>
681 inline typename MakeReturn<
682  BinaryNode<OpMod, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
683  operator%(const T1& l, const Expression<T2>& r)
684 {
685  using Tree_t = BinaryNode<OpMod, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
686  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
687 }
688 
689 template<class T1, class T2>
690 inline typename MakeReturn<
691  BinaryNode<OpBitwiseAnd, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
692  Expression_t
693  operator&(const T1& l, const Expression<T2>& r)
694 {
695  using Tree_t = BinaryNode<OpBitwiseAnd, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
696  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
697 }
698 
699 template<class T1, class T2>
700 inline typename MakeReturn<
701  BinaryNode<OpBitwiseOr, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
702  operator|(const T1& l, const Expression<T2>& r)
703 {
704  using Tree_t = BinaryNode<OpBitwiseOr, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
705  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
706 }
707 
708 template<class T1, class T2>
709 inline typename MakeReturn<
710  BinaryNode<OpBitwiseXor, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
711  Expression_t
712  operator^(const T1& l, const Expression<T2>& r)
713 {
714  using Tree_t = BinaryNode<OpBitwiseXor, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
715  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
716 }
717 #ifdef PETE_ALLOW_SCALAR_SHIFT
718 #endif // PETE_ALLOW_SCALAR_SHIFT
719 
720 template<class T1, class T2, class T3>
721 inline typename MakeReturn<TrinaryNode<FnWhere,
722  typename CreateLeaf<Expression<T1>>::Leaf_t,
723  typename CreateLeaf<T2>::Leaf_t,
724  typename CreateLeaf<T3>::Leaf_t>>::Expression_t
725  where(const Expression<T1>& c, const T2& t, const T3& f)
726 {
727  typedef TrinaryNode<FnWhere, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t,
728  typename CreateLeaf<T3>::Leaf_t>
729  Tree_t;
730  return MakeReturn<Tree_t>::make(
731  Tree_t(CreateLeaf<Expression<T1>>::make(c), CreateLeaf<T2>::make(t), CreateLeaf<T3>::make(f)));
732 }
733 #endif // PETE_EXPRESSION_OPERATORS
734 
735 template<class T1, class C1, class RHS>
736 inline Matrix<T1, C1>& assign(Matrix<T1, C1>& lhs, const RHS& rhs)
737 {
738  using Leaf_t = typename CreateLeaf<RHS>::Leaf_t;
739  evaluate(lhs, OpAssign(), MakeReturn<Leaf_t>::make(CreateLeaf<RHS>::make(rhs)));
740  return lhs;
741 }
742 
743 template<class T1, class C1, class RHS>
744 inline Matrix<T1, C1>& operator+=(Matrix<T1, C1>& lhs, const RHS& rhs)
745 {
746  using Leaf_t = typename CreateLeaf<RHS>::Leaf_t;
747  evaluate(lhs, OpAddAssign(), MakeReturn<Leaf_t>::make(CreateLeaf<RHS>::make(rhs)));
748  return lhs;
749 }
750 
751 template<class T1, class C1, class RHS>
752 inline Matrix<T1, C1>& operator-=(Matrix<T1, C1>& lhs, const RHS& rhs)
753 {
754  using Leaf_t = typename CreateLeaf<RHS>::Leaf_t;
755  evaluate(lhs, OpSubtractAssign(), MakeReturn<Leaf_t>::make(CreateLeaf<RHS>::make(rhs)));
756  return lhs;
757 }
758 
759 template<class T1, class C1, class RHS>
760 inline Matrix<T1, C1>& operator*=(Matrix<T1, C1>& lhs, const RHS& rhs)
761 {
762  using Leaf_t = typename CreateLeaf<RHS>::Leaf_t;
763  evaluate(lhs, OpMultiplyAssign(), MakeReturn<Leaf_t>::make(CreateLeaf<RHS>::make(rhs)));
764  return lhs;
765 }
766 
767 template<class T1, class C1, class RHS>
768 inline Matrix<T1, C1>& operator%=(Matrix<T1, C1>& lhs, const RHS& rhs)
769 {
770  using Leaf_t = typename CreateLeaf<RHS>::Leaf_t;
771  evaluate(lhs, OpModAssign(), MakeReturn<Leaf_t>::make(CreateLeaf<RHS>::make(rhs)));
772  return lhs;
773 }
774 
775 template<class T1, class C1, class RHS>
776 inline Matrix<T1, C1>& operator|=(Matrix<T1, C1>& lhs, const RHS& rhs)
777 {
778  using Leaf_t = typename CreateLeaf<RHS>::Leaf_t;
779  evaluate(lhs, OpBitwiseOrAssign(), MakeReturn<Leaf_t>::make(CreateLeaf<RHS>::make(rhs)));
780  return lhs;
781 }
782 
783 template<class T1, class C1, class RHS>
784 inline Matrix<T1, C1>& operator&=(Matrix<T1, C1>& lhs, const RHS& rhs)
785 {
786  using Leaf_t = typename CreateLeaf<RHS>::Leaf_t;
787  evaluate(lhs, OpBitwiseAndAssign(), MakeReturn<Leaf_t>::make(CreateLeaf<RHS>::make(rhs)));
788  return lhs;
789 }
790 
791 template<class T1, class C1, class RHS>
792 inline Matrix<T1, C1>& operator^=(Matrix<T1, C1>& lhs, const RHS& rhs)
793 {
794  using Leaf_t = typename CreateLeaf<RHS>::Leaf_t;
795  evaluate(lhs, OpBitwiseXorAssign(), MakeReturn<Leaf_t>::make(CreateLeaf<RHS>::make(rhs)));
796  return lhs;
797 }
798 
799 } // namespace qmcplusplus
800 
801 #endif // OHMMS_MATRIXOPERATOR_H
802 
803 /*
804 MatrixDefs.in
805 classes
806 -----
807  ARG = "class T[n], class C[n]"
808  CLASS = "Matrix<T[n], C[n]>"
809 
810 
811 unaryOps
812 -----
813  TAG = "OpUnaryMinus"
814  FUNCTION = "operator-"
815  EXPR = "return (-a);"
816 -----
817  TAG = "OpUnaryPlus"
818  FUNCTION = "operator+"
819  EXPR = "return (+a);"
820 -----
821  TAG = "OpBitwiseNot"
822  FUNCTION = "operator~"
823  EXPR = "return (~a);"
824 -----
825  TAG = "OpIdentity"
826  FUNCTION = "PETE_identity"
827  EXPR = "return (a);"
828 
829 unaryCastOps
830 -----
831  TAG = "OpCast"
832  FUNCTION = "peteCast"
833  EXPR = "return T1(a);"
834 
835 binaryOps
836 -----
837  TAG = "OpAdd"
838  FUNCTION = "operator+"
839  EXPR = "return (a + b);"
840 -----
841  TAG = "OpSubtract"
842  FUNCTION = "operator-"
843  EXPR = "return (a - b);"
844 -----
845  TAG = "OpMultiply"
846  FUNCTION = "operator*"
847  EXPR = "return (a * b);"
848 -----
849  TAG = "OpMod"
850  FUNCTION = "operator%"
851  EXPR = "return (a % b);"
852 -----
853  TAG = "OpBitwiseAnd"
854  FUNCTION = "operator&"
855  EXPR = "return (a & b);"
856 -----
857  TAG = "OpBitwiseOr"
858  FUNCTION = "operator|"
859  EXPR = "return (a | b);"
860 -----
861  TAG = "OpBitwiseXor"
862  FUNCTION = "operator^"
863  EXPR = "return (a ^ b);"
864 
865 assignOp
866 -----
867  TAG = "OpAssign"
868  FUNCTION = "assign"
869  EXPR = "return (const_cast<T1 &>(a) = b);"
870 
871 binaryAssignOps
872 -----
873  TAG = "OpAddAssign"
874  FUNCTION = "operator+="
875  EXPR = "(const_cast<T1 &>(a) += b); return const_cast<T1 &>(a);"
876 -----
877  TAG = "OpSubtractAssign"
878  FUNCTION = "operator-="
879  EXPR = "(const_cast<T1 &>(a) -= b); return const_cast<T1 &>(a);"
880 -----
881  TAG = "OpMultiplyAssign"
882  FUNCTION = "operator*="
883  EXPR = "(const_cast<T1 &>(a) *= b); return const_cast<T1 &>(a);"
884 -----
885  TAG = "OpModAssign"
886  FUNCTION = "operator%="
887  EXPR = "(const_cast<T1 &>(a) %= b); return const_cast<T1 &>(a);"
888 -----
889  TAG = "OpBitwiseOrAssign"
890  FUNCTION = "operator|="
891  EXPR = "(const_cast<T1 &>(a) |= b); return const_cast<T1 &>(a);"
892 -----
893  TAG = "OpBitwiseAndAssign"
894  FUNCTION = "operator&="
895  EXPR = "(const_cast<T1 &>(a) &= b); return const_cast<T1 &>(a);"
896 -----
897  TAG = "OpBitwiseXorAssign"
898  FUNCTION = "operator^="
899  EXPR = "(const_cast<T1 &>(a) ^= b); return const_cast<T1 &>(a);"
900 
901 trinaryOps
902 -----
903  TAG = "FnWhere"
904  FUNCTION = "where"
905  EXPR = "if (a) return b; else return c;"
906 */
qmcplusplus::operator*
MakeReturn< BinaryNode< OpMultiply, typename CreateLeaf< Matrix< T1, C1 > >::Leaf_t, typename CreateLeaf< Matrix< T2, C2 > >::Leaf_t > >::Expression_t operator*(const Matrix< T1, C1 > &l, const Matrix< T2, C2 > &r)
Definition: OhmmsMatrixOperators.h:98
qmcplusplus::operator%=
Matrix< T1, C1 > & operator%=(Matrix< T1, C1 > &lhs, const RHS &rhs)
Definition: OhmmsMatrixOperators.h:768
qmcplusplus::operator|=
Matrix< T1, C1 > & operator|=(Matrix< T1, C1 > &lhs, const RHS &rhs)
Definition: OhmmsMatrixOperators.h:776
qmcplusplus::operator%
MakeReturn< BinaryNode< OpMod, typename CreateLeaf< Matrix< T1, C1 > >::Leaf_t, typename CreateLeaf< Matrix< T2, C2 > >::Leaf_t > >::Expression_t operator%(const Matrix< T1, C1 > &l, const Matrix< T2, C2 > &r)
Definition: OhmmsMatrixOperators.h:110
qmcplusplus
helper functions for EinsplineSetBuilder
Definition: Configuration.h:43
Scalar
Definition: Scalar.h:49
qmcplusplus::operator~
MakeReturn< UnaryNode< OpBitwiseNot, typename CreateLeaf< Matrix< T1, C1 > >::Leaf_t > >::Expression_t operator~(const Matrix< T1, C1 > &l)
Definition: OhmmsMatrixOperators.h:47
qmcplusplus::operator-
MakeReturn< UnaryNode< OpUnaryMinus, typename CreateLeaf< Matrix< T1, C1 > >::Leaf_t > >::Expression_t operator-(const Matrix< T1, C1 > &l)
Definition: OhmmsMatrixOperators.h:31
qmcplusplus::where
MakeReturn< TrinaryNode< FnWhere, typename CreateLeaf< Matrix< T1, C1 > >::Leaf_t, typename CreateLeaf< T2 >::Leaf_t, typename CreateLeaf< T3 >::Leaf_t > >::Expression_t where(const Matrix< T1, C1 > &c, const T2 &t, const T3 &f)
Definition: OhmmsMatrixOperators.h:454
qmcplusplus::operator+
const AntiSymTensor< T, D > & operator+(const AntiSymTensor< T, D > &op)
Definition: AntiSymTensor.h:495
qmcplusplus::operator+=
Matrix< T1, C1 > & operator+=(Matrix< T1, C1 > &lhs, const RHS &rhs)
Definition: OhmmsMatrixOperators.h:744
qmcplusplus::MakeReturn::make
static Expression_t make(const T &a)
Definition: CreateLeaf.h:132
qmcplusplus::operator &=
Matrix< T1, C1 > & operator &=(Matrix< T1, C1 > &lhs, const RHS &rhs)
Definition: OhmmsMatrixOperators.h:784
qmcplusplus::operator &
MakeReturn< BinaryNode< OpBitwiseAnd, typename CreateLeaf< Matrix< T1, C1 > >::Leaf_t, typename CreateLeaf< Matrix< T2, C2 > >::Leaf_t > >::Expression_t operator &(const Matrix< T1, C1 > &l, const Matrix< T2, C2 > &r)
Definition: OhmmsMatrixOperators.h:121
qmcplusplus::operator^=
Matrix< T1, C1 > & operator^=(Matrix< T1, C1 > &lhs, const RHS &rhs)
Definition: OhmmsMatrixOperators.h:792
qmcplusplus::assign
Matrix< T1, C1 > & assign(Matrix< T1, C1 > &lhs, const RHS &rhs)
Definition: OhmmsMatrixOperators.h:736
qmcplusplus::operator^
MakeReturn< BinaryNode< OpBitwiseXor, typename CreateLeaf< Matrix< T1, C1 > >::Leaf_t, typename CreateLeaf< Matrix< T2, C2 > >::Leaf_t > >::Expression_t operator^(const Matrix< T1, C1 > &l, const Matrix< T2, C2 > &r)
Definition: OhmmsMatrixOperators.h:145
qmcplusplus::peteCast
MakeReturn< UnaryNode< OpCast< T1 >, typename CreateLeaf< Matrix< T2, C2 > >::Leaf_t > >::Expression_t peteCast(const T1 &, const Matrix< T2, C2 > &l)
Definition: OhmmsMatrixOperators.h:62
qmcplusplus::operator*=
Matrix< T1, C1 > & operator*=(Matrix< T1, C1 > &lhs, const RHS &rhs)
Definition: OhmmsMatrixOperators.h:760
qmcplusplus::operator-=
Matrix< T1, C1 > & operator-=(Matrix< T1, C1 > &lhs, const RHS &rhs)
Definition: OhmmsMatrixOperators.h:752
qmcplusplus::evaluate
void evaluate(Matrix< T, Alloc > &lhs, const Op &op, const Expression< RHS > &rhs)
Definition: OhmmsMatrix.h:514
qmcplusplus::PETE_identity
MakeReturn< UnaryNode< OpIdentity, typename CreateLeaf< Matrix< T1, C1 > >::Leaf_t > >::Expression_t PETE_identity(const Matrix< T1, C1 > &l)
Definition: OhmmsMatrixOperators.h:55
qmcplusplus::operator|
MakeReturn< BinaryNode< OpBitwiseOr, typename CreateLeaf< Matrix< T1, C1 > >::Leaf_t, typename CreateLeaf< Matrix< T2, C2 > >::Leaf_t > >::Expression_t operator|(const Matrix< T1, C1 > &l, const Matrix< T2, C2 > &r)
Definition: OhmmsMatrixOperators.h:133