QMCPACK
OhmmsVectorOperators.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 
13 #ifndef OHMMS_VECTOR_OPERATORS_H
14 #define OHMMS_VECTOR_OPERATORS_H
15 
16 namespace qmcplusplus
17 {
18 ///////////////////////////////////////////////////////////////////////////////
19 //
20 // WARNING: THIS FILE WAS GENERATED AUTOMATICALLY!
21 // YOU SHOULD MODIFY THE INPUT FILES INSTEAD OF CHANGING THIS FILE DIRECTLY!
22 //
23 // THE FOLLOWING INPUT FILES WERE USED TO MAKE THIS FILE:
24 //
25 // MakeOperators
26 // VectorDefs.in
27 //
28 ///////////////////////////////////////////////////////////////////////////////
29 
30 
31 template<class T1, class C1>
32 inline typename MakeReturn<UnaryNode<FnArcCos, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>>::Expression_t acos(
33  const Vector<T1, C1>& l)
34 {
35  using Tree_t = UnaryNode<FnArcCos, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>;
36  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l)));
37 }
38 
39 template<class T1, class C1>
40 inline typename MakeReturn<UnaryNode<FnArcSin, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>>::Expression_t asin(
41  const Vector<T1, C1>& l)
42 {
43  using Tree_t = UnaryNode<FnArcSin, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>;
44  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l)));
45 }
46 
47 template<class T1, class C1>
48 inline typename MakeReturn<UnaryNode<FnArcTan, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>>::Expression_t atan(
49  const Vector<T1, C1>& l)
50 {
51  using Tree_t = UnaryNode<FnArcTan, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>;
52  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l)));
53 }
54 
55 template<class T1, class C1>
56 inline typename MakeReturn<UnaryNode<FnCeil, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>>::Expression_t ceil(
57  const Vector<T1, C1>& l)
58 {
59  using Tree_t = UnaryNode<FnCeil, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>;
60  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l)));
61 }
62 
63 template<class T1, class C1>
64 inline typename MakeReturn<UnaryNode<FnCos, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>>::Expression_t cos(
65  const Vector<T1, C1>& l)
66 {
67  using Tree_t = UnaryNode<FnCos, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>;
68  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l)));
69 }
70 
71 template<class T1, class C1>
72 inline typename MakeReturn<UnaryNode<FnHypCos, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>>::Expression_t cosh(
73  const Vector<T1, C1>& l)
74 {
75  using Tree_t = UnaryNode<FnHypCos, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>;
76  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l)));
77 }
78 
79 template<class T1, class C1>
80 inline typename MakeReturn<UnaryNode<FnExp, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>>::Expression_t exp(
81  const Vector<T1, C1>& l)
82 {
83  using Tree_t = UnaryNode<FnExp, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>;
84  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l)));
85 }
86 
87 template<class T1, class C1>
88 inline typename MakeReturn<UnaryNode<FnFabs, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>>::Expression_t abs(
89  const Vector<T1, C1>& l)
90 {
91  using Tree_t = UnaryNode<FnFabs, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>;
92  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l)));
93 }
94 
95 template<class T1, class C1>
96 inline typename MakeReturn<UnaryNode<FnFloor, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>>::Expression_t floor(
97  const Vector<T1, C1>& l)
98 {
99  using Tree_t = UnaryNode<FnFloor, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>;
100  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l)));
101 }
102 
103 template<class T1, class C1>
104 inline typename MakeReturn<UnaryNode<FnLog, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>>::Expression_t log(
105  const Vector<T1, C1>& l)
106 {
107  using Tree_t = UnaryNode<FnLog, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>;
108  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l)));
109 }
110 
111 template<class T1, class C1>
112 inline typename MakeReturn<UnaryNode<FnLog10, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>>::Expression_t log10(
113  const Vector<T1, C1>& l)
114 {
115  using Tree_t = UnaryNode<FnLog10, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>;
116  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l)));
117 }
118 
119 template<class T1, class C1>
120 inline typename MakeReturn<UnaryNode<FnSin, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>>::Expression_t sin(
121  const Vector<T1, C1>& l)
122 {
123  using Tree_t = UnaryNode<FnSin, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>;
124  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l)));
125 }
126 
127 template<class T1, class C1>
128 inline typename MakeReturn<UnaryNode<FnHypSin, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>>::Expression_t sinh(
129  const Vector<T1, C1>& l)
130 {
131  using Tree_t = UnaryNode<FnHypSin, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>;
132  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l)));
133 }
134 
135 template<class T1, class C1>
136 inline typename MakeReturn<UnaryNode<FnSqrt, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>>::Expression_t sqrt(
137  const Vector<T1, C1>& l)
138 {
139  using Tree_t = UnaryNode<FnSqrt, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>;
140  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l)));
141 }
142 
143 template<class T1, class C1>
144 inline typename MakeReturn<UnaryNode<FnTan, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>>::Expression_t tan(
145  const Vector<T1, C1>& l)
146 {
147  using Tree_t = UnaryNode<FnTan, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>;
148  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l)));
149 }
150 
151 template<class T1, class C1>
152 inline typename MakeReturn<UnaryNode<FnHypTan, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>>::Expression_t tanh(
153  const Vector<T1, C1>& l)
154 {
155  using Tree_t = UnaryNode<FnHypTan, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>;
156  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l)));
157 }
158 
159 template<class T1, class C1>
160 inline typename MakeReturn<UnaryNode<OpUnaryMinus, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>>::Expression_t
161  operator-(const Vector<T1, C1>& l)
162 {
163  using Tree_t = UnaryNode<OpUnaryMinus, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>;
164  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l)));
165 }
166 
167 template<class T1, class C1>
168 inline typename MakeReturn<UnaryNode<OpUnaryPlus, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>>::Expression_t operator+(
169  const Vector<T1, C1>& l)
170 {
171  using Tree_t = UnaryNode<OpUnaryPlus, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>;
172  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l)));
173 }
174 
175 template<class T1, class C1>
176 inline typename MakeReturn<UnaryNode<OpBitwiseNot, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>>::Expression_t
177  operator~(const Vector<T1, C1>& l)
178 {
179  using Tree_t = UnaryNode<OpBitwiseNot, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>;
180  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l)));
181 }
182 
183 template<class T1, class C1>
184 inline typename MakeReturn<UnaryNode<OpIdentity, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>>::Expression_t
185  PETE_identity(const Vector<T1, C1>& l)
186 {
187  using Tree_t = UnaryNode<OpIdentity, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>;
188  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l)));
189 }
190 
191 template<class T1, class C1>
192 inline typename MakeReturn<UnaryNode<OpNot, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>>::Expression_t operator!(
193  const Vector<T1, C1>& l)
194 {
195  using Tree_t = UnaryNode<OpNot, typename CreateLeaf<Vector<T1, C1>>::Leaf_t>;
196  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l)));
197 }
198 
199 template<class T1, class T2, class C2>
200 inline typename MakeReturn<UnaryNode<OpCast<T1>, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::Expression_t peteCast(
201  const T1&,
202  const Vector<T2, C2>& l)
203 {
204  using Tree_t = UnaryNode<OpCast<T1>, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>;
205  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T2, C2>>::make(l)));
206 }
207 
208 template<class T1, class C1, class T2, class C2>
209 inline typename MakeReturn<
210  BinaryNode<OpAdd, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
211  Expression_t
212  operator+(const Vector<T1, C1>& l, const Vector<T2, C2>& r)
213 {
214  typedef BinaryNode<OpAdd, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
215  Tree_t;
216  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
217 }
218 
219 template<class T1, class C1, class T2, class C2>
220 inline typename MakeReturn<
221  BinaryNode<OpSubtract, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
222  Expression_t
223  operator-(const Vector<T1, C1>& l, const Vector<T2, C2>& r)
224 {
225  typedef BinaryNode<OpSubtract, typename CreateLeaf<Vector<T1, C1>>::Leaf_t,
226  typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
227  Tree_t;
228  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
229 }
230 
231 template<class T1, class C1, class T2, class C2>
232 inline typename MakeReturn<
233  BinaryNode<OpMultiply, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
234  Expression_t
235  operator*(const Vector<T1, C1>& l, const Vector<T2, C2>& r)
236 {
237  typedef BinaryNode<OpMultiply, typename CreateLeaf<Vector<T1, C1>>::Leaf_t,
238  typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
239  Tree_t;
240  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
241 }
242 
243 template<class T1, class C1, class T2, class C2>
244 inline typename MakeReturn<
245  BinaryNode<OpDivide, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
246  Expression_t
247  operator/(const Vector<T1, C1>& l, const Vector<T2, C2>& r)
248 {
249  typedef BinaryNode<OpDivide, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
250  Tree_t;
251  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
252 }
253 
254 template<class T1, class C1, class T2, class C2>
255 inline typename MakeReturn<
256  BinaryNode<OpMod, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
257  Expression_t
258  operator%(const Vector<T1, C1>& l, const Vector<T2, C2>& r)
259 {
260  typedef BinaryNode<OpMod, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
261  Tree_t;
262  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
263 }
264 
265 template<class T1, class C1, class T2, class C2>
266 inline typename MakeReturn<BinaryNode<OpBitwiseAnd,
267  typename CreateLeaf<Vector<T1, C1>>::Leaf_t,
268  typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::Expression_t
269  operator&(const Vector<T1, C1>& l, const Vector<T2, C2>& r)
270 {
271  typedef BinaryNode<OpBitwiseAnd, typename CreateLeaf<Vector<T1, C1>>::Leaf_t,
272  typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
273  Tree_t;
274  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
275 }
276 
277 template<class T1, class C1, class T2, class C2>
278 inline typename MakeReturn<
279  BinaryNode<OpBitwiseOr, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
280  Expression_t
281  operator|(const Vector<T1, C1>& l, const Vector<T2, C2>& r)
282 {
283  typedef BinaryNode<OpBitwiseOr, typename CreateLeaf<Vector<T1, C1>>::Leaf_t,
284  typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
285  Tree_t;
286  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
287 }
288 
289 template<class T1, class C1, class T2, class C2>
290 inline typename MakeReturn<BinaryNode<OpBitwiseXor,
291  typename CreateLeaf<Vector<T1, C1>>::Leaf_t,
292  typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::Expression_t
293  operator^(const Vector<T1, C1>& l, const Vector<T2, C2>& r)
294 {
295  typedef BinaryNode<OpBitwiseXor, typename CreateLeaf<Vector<T1, C1>>::Leaf_t,
296  typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
297  Tree_t;
298  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
299 }
300 
301 template<class T1, class C1, class T2, class C2>
302 inline typename MakeReturn<
303  BinaryNode<FnLdexp, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
304  Expression_t
305  ldexp(const Vector<T1, C1>& l, const Vector<T2, C2>& r)
306 {
307  typedef BinaryNode<FnLdexp, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
308  Tree_t;
309  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
310 }
311 
312 template<class T1, class C1, class T2, class C2>
313 inline typename MakeReturn<
314  BinaryNode<FnPow, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
315  Expression_t
316  pow(const Vector<T1, C1>& l, const Vector<T2, C2>& r)
317 {
318  typedef BinaryNode<FnPow, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
319  Tree_t;
320  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
321 }
322 
323 template<class T1, class C1, class T2, class C2>
324 inline typename MakeReturn<
325  BinaryNode<FnFmod, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
326  Expression_t
327  fmod(const Vector<T1, C1>& l, const Vector<T2, C2>& r)
328 {
329  typedef BinaryNode<FnFmod, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
330  Tree_t;
331  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
332 }
333 
334 template<class T1, class C1, class T2, class C2>
335 inline typename MakeReturn<
336  BinaryNode<FnArcTan2, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
337  Expression_t
338  atan2(const Vector<T1, C1>& l, const Vector<T2, C2>& r)
339 {
340  typedef BinaryNode<FnArcTan2, typename CreateLeaf<Vector<T1, C1>>::Leaf_t,
341  typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
342  Tree_t;
343  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
344 }
345 
346 template<class T1, class C1, class T2, class C2>
347 inline typename MakeReturn<
348  BinaryNode<OpLT, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
349  Expression_t
350  operator<(const Vector<T1, C1>& l, const Vector<T2, C2>& r)
351 {
352  typedef BinaryNode<OpLT, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
353  Tree_t;
354  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
355 }
356 
357 template<class T1, class C1, class T2, class C2>
358 inline typename MakeReturn<
359  BinaryNode<OpLE, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
360  Expression_t
361  operator<=(const Vector<T1, C1>& l, const Vector<T2, C2>& r)
362 {
363  typedef BinaryNode<OpLE, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
364  Tree_t;
365  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
366 }
367 
368 template<class T1, class C1, class T2, class C2>
369 inline typename MakeReturn<
370  BinaryNode<OpGT, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
371  Expression_t
372  operator>(const Vector<T1, C1>& l, const Vector<T2, C2>& r)
373 {
374  typedef BinaryNode<OpGT, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
375  Tree_t;
376  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
377 }
378 
379 template<class T1, class C1, class T2, class C2>
380 inline typename MakeReturn<
381  BinaryNode<OpGE, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
382  Expression_t
383  operator>=(const Vector<T1, C1>& l, const Vector<T2, C2>& r)
384 {
385  typedef BinaryNode<OpGE, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
386  Tree_t;
387  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
388 }
389 
390 template<class T1, class C1, class T2, class C2>
391 inline typename MakeReturn<
392  BinaryNode<OpEQ, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
393  Expression_t
394  operator==(const Vector<T1, C1>& l, const Vector<T2, C2>& r)
395 {
396  typedef BinaryNode<OpEQ, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
397  Tree_t;
398  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
399 }
400 
401 template<class T1, class C1, class T2, class C2>
402 inline typename MakeReturn<
403  BinaryNode<OpNE, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
404  Expression_t
405  operator!=(const Vector<T1, C1>& l, const Vector<T2, C2>& r)
406 {
407  typedef BinaryNode<OpNE, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
408  Tree_t;
409  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
410 }
411 
412 template<class T1, class C1, class T2, class C2>
413 inline typename MakeReturn<
414  BinaryNode<OpAnd, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
415  Expression_t
416  operator&&(const Vector<T1, C1>& l, const Vector<T2, C2>& r)
417 {
418  typedef BinaryNode<OpAnd, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
419  Tree_t;
420  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
421 }
422 
423 template<class T1, class C1, class T2, class C2>
424 inline typename MakeReturn<
425  BinaryNode<OpOr, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
426  Expression_t
427  operator||(const Vector<T1, C1>& l, const Vector<T2, C2>& r)
428 {
429  typedef BinaryNode<OpOr, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
430  Tree_t;
431  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
432 }
433 
434 template<class T1, class C1, class T2, class C2>
435 inline typename MakeReturn<
436  BinaryNode<OpLeftShift, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
437  Expression_t
438  operator<<(const Vector<T1, C1>& l, const Vector<T2, C2>& r)
439 {
440  typedef BinaryNode<OpLeftShift, typename CreateLeaf<Vector<T1, C1>>::Leaf_t,
441  typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
442  Tree_t;
443  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
444 }
445 
446 template<class T1, class C1, class T2, class C2>
447 inline typename MakeReturn<BinaryNode<OpRightShift,
448  typename CreateLeaf<Vector<T1, C1>>::Leaf_t,
449  typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::Expression_t
450  operator>>(const Vector<T1, C1>& l, const Vector<T2, C2>& r)
451 {
452  typedef BinaryNode<OpRightShift, typename CreateLeaf<Vector<T1, C1>>::Leaf_t,
453  typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
454  Tree_t;
455  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
456 }
457 
458 template<class T1, class C1, class T2>
459 inline typename MakeReturn<
460  BinaryNode<OpAdd, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
461  Expression_t
462  operator+(const Vector<T1, C1>& l, const Expression<T2>& r)
463 {
464  typedef BinaryNode<OpAdd, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
465  Tree_t;
466  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
467 }
468 
469 template<class T1, class C1, class T2>
470 inline typename MakeReturn<
471  BinaryNode<OpSubtract, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
472  Expression_t
473  operator-(const Vector<T1, C1>& l, const Expression<T2>& r)
474 {
475  typedef BinaryNode<OpSubtract, typename CreateLeaf<Vector<T1, C1>>::Leaf_t,
476  typename CreateLeaf<Expression<T2>>::Leaf_t>
477  Tree_t;
478  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
479 }
480 
481 template<class T1, class C1, class T2>
482 inline typename MakeReturn<
483  BinaryNode<OpMultiply, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
484  Expression_t
485  operator*(const Vector<T1, C1>& l, const Expression<T2>& r)
486 {
487  typedef BinaryNode<OpMultiply, typename CreateLeaf<Vector<T1, C1>>::Leaf_t,
488  typename CreateLeaf<Expression<T2>>::Leaf_t>
489  Tree_t;
490  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
491 }
492 
493 template<class T1, class C1, class T2>
494 inline typename MakeReturn<
495  BinaryNode<OpDivide, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
496  Expression_t
497  operator/(const Vector<T1, C1>& l, const Expression<T2>& r)
498 {
499  typedef BinaryNode<OpDivide, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
500  Tree_t;
501  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
502 }
503 
504 template<class T1, class C1, class T2>
505 inline typename MakeReturn<
506  BinaryNode<OpMod, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
507  Expression_t
508  operator%(const Vector<T1, C1>& l, const Expression<T2>& r)
509 {
510  typedef BinaryNode<OpMod, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
511  Tree_t;
512  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
513 }
514 
515 template<class T1, class C1, class T2>
516 inline typename MakeReturn<BinaryNode<OpBitwiseAnd,
517  typename CreateLeaf<Vector<T1, C1>>::Leaf_t,
518  typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
519  operator&(const Vector<T1, C1>& l, const Expression<T2>& r)
520 {
521  typedef BinaryNode<OpBitwiseAnd, typename CreateLeaf<Vector<T1, C1>>::Leaf_t,
522  typename CreateLeaf<Expression<T2>>::Leaf_t>
523  Tree_t;
524  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
525 }
526 
527 template<class T1, class C1, class T2>
528 inline typename MakeReturn<
529  BinaryNode<OpBitwiseOr, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
530  Expression_t
531  operator|(const Vector<T1, C1>& l, const Expression<T2>& r)
532 {
533  typedef BinaryNode<OpBitwiseOr, typename CreateLeaf<Vector<T1, C1>>::Leaf_t,
534  typename CreateLeaf<Expression<T2>>::Leaf_t>
535  Tree_t;
536  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
537 }
538 
539 template<class T1, class C1, class T2>
540 inline typename MakeReturn<BinaryNode<OpBitwiseXor,
541  typename CreateLeaf<Vector<T1, C1>>::Leaf_t,
542  typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
543  operator^(const Vector<T1, C1>& l, const Expression<T2>& r)
544 {
545  typedef BinaryNode<OpBitwiseXor, typename CreateLeaf<Vector<T1, C1>>::Leaf_t,
546  typename CreateLeaf<Expression<T2>>::Leaf_t>
547  Tree_t;
548  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
549 }
550 
551 template<class T1, class C1, class T2>
552 inline typename MakeReturn<
553  BinaryNode<FnLdexp, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
554  Expression_t
555  ldexp(const Vector<T1, C1>& l, const Expression<T2>& r)
556 {
557  typedef BinaryNode<FnLdexp, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
558  Tree_t;
559  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
560 }
561 
562 template<class T1, class C1, class T2>
563 inline typename MakeReturn<
564  BinaryNode<FnPow, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
565  Expression_t
566  pow(const Vector<T1, C1>& l, const Expression<T2>& r)
567 {
568  typedef BinaryNode<FnPow, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
569  Tree_t;
570  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
571 }
572 
573 template<class T1, class C1, class T2>
574 inline typename MakeReturn<
575  BinaryNode<FnFmod, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
576  Expression_t
577  fmod(const Vector<T1, C1>& l, const Expression<T2>& r)
578 {
579  typedef BinaryNode<FnFmod, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
580  Tree_t;
581  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
582 }
583 
584 template<class T1, class C1, class T2>
585 inline typename MakeReturn<
586  BinaryNode<FnArcTan2, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
587  Expression_t
588  atan2(const Vector<T1, C1>& l, const Expression<T2>& r)
589 {
590  typedef BinaryNode<FnArcTan2, typename CreateLeaf<Vector<T1, C1>>::Leaf_t,
591  typename CreateLeaf<Expression<T2>>::Leaf_t>
592  Tree_t;
593  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
594 }
595 
596 template<class T1, class C1, class T2>
597 inline typename MakeReturn<
598  BinaryNode<OpLT, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
599  Expression_t
600  operator<(const Vector<T1, C1>& l, const Expression<T2>& r)
601 {
602  typedef BinaryNode<OpLT, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
603  Tree_t;
604  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
605 }
606 
607 template<class T1, class C1, class T2>
608 inline typename MakeReturn<
609  BinaryNode<OpLE, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
610  Expression_t
611  operator<=(const Vector<T1, C1>& l, const Expression<T2>& r)
612 {
613  typedef BinaryNode<OpLE, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
614  Tree_t;
615  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
616 }
617 
618 template<class T1, class C1, class T2>
619 inline typename MakeReturn<
620  BinaryNode<OpGT, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
621  Expression_t
622  operator>(const Vector<T1, C1>& l, const Expression<T2>& r)
623 {
624  typedef BinaryNode<OpGT, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
625  Tree_t;
626  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
627 }
628 
629 template<class T1, class C1, class T2>
630 inline typename MakeReturn<
631  BinaryNode<OpGE, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
632  Expression_t
633  operator>=(const Vector<T1, C1>& l, const Expression<T2>& r)
634 {
635  typedef BinaryNode<OpGE, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
636  Tree_t;
637  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
638 }
639 
640 template<class T1, class C1, class T2>
641 inline typename MakeReturn<
642  BinaryNode<OpEQ, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
643  Expression_t
644  operator==(const Vector<T1, C1>& l, const Expression<T2>& r)
645 {
646  typedef BinaryNode<OpEQ, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
647  Tree_t;
648  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
649 }
650 
651 template<class T1, class C1, class T2>
652 inline typename MakeReturn<
653  BinaryNode<OpNE, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
654  Expression_t
655  operator!=(const Vector<T1, C1>& l, const Expression<T2>& r)
656 {
657  typedef BinaryNode<OpNE, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
658  Tree_t;
659  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
660 }
661 
662 template<class T1, class C1, class T2>
663 inline typename MakeReturn<
664  BinaryNode<OpAnd, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
665  Expression_t
666  operator&&(const Vector<T1, C1>& l, const Expression<T2>& r)
667 {
668  typedef BinaryNode<OpAnd, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
669  Tree_t;
670  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
671 }
672 
673 template<class T1, class C1, class T2>
674 inline typename MakeReturn<
675  BinaryNode<OpOr, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
676  Expression_t
677  operator||(const Vector<T1, C1>& l, const Expression<T2>& r)
678 {
679  typedef BinaryNode<OpOr, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
680  Tree_t;
681  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
682 }
683 
684 template<class T1, class C1, class T2>
685 inline typename MakeReturn<
686  BinaryNode<OpLeftShift, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
687  Expression_t
688  operator<<(const Vector<T1, C1>& l, const Expression<T2>& r)
689 {
690  typedef BinaryNode<OpLeftShift, typename CreateLeaf<Vector<T1, C1>>::Leaf_t,
691  typename CreateLeaf<Expression<T2>>::Leaf_t>
692  Tree_t;
693  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
694 }
695 
696 template<class T1, class C1, class T2>
697 inline typename MakeReturn<BinaryNode<OpRightShift,
698  typename CreateLeaf<Vector<T1, C1>>::Leaf_t,
699  typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
700  operator>>(const Vector<T1, C1>& l, const Expression<T2>& r)
701 {
702  typedef BinaryNode<OpRightShift, typename CreateLeaf<Vector<T1, C1>>::Leaf_t,
703  typename CreateLeaf<Expression<T2>>::Leaf_t>
704  Tree_t;
705  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
706 }
707 
708 template<class T1, class T2, class C2>
709 inline typename MakeReturn<
710  BinaryNode<OpAdd, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
711  Expression_t
712  operator+(const Expression<T1>& l, const Vector<T2, C2>& r)
713 {
714  typedef BinaryNode<OpAdd, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
715  Tree_t;
716  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
717 }
718 
719 template<class T1, class T2, class C2>
720 inline typename MakeReturn<
721  BinaryNode<OpSubtract, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
722  Expression_t
723  operator-(const Expression<T1>& l, const Vector<T2, C2>& r)
724 {
725  typedef BinaryNode<OpSubtract, typename CreateLeaf<Expression<T1>>::Leaf_t,
726  typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
727  Tree_t;
728  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
729 }
730 
731 template<class T1, class T2, class C2>
732 inline typename MakeReturn<
733  BinaryNode<OpMultiply, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
734  Expression_t
735  operator*(const Expression<T1>& l, const Vector<T2, C2>& r)
736 {
737  typedef BinaryNode<OpMultiply, typename CreateLeaf<Expression<T1>>::Leaf_t,
738  typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
739  Tree_t;
740  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
741 }
742 
743 template<class T1, class T2, class C2>
744 inline typename MakeReturn<
745  BinaryNode<OpDivide, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
746  Expression_t
747  operator/(const Expression<T1>& l, const Vector<T2, C2>& r)
748 {
749  typedef BinaryNode<OpDivide, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
750  Tree_t;
751  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
752 }
753 
754 template<class T1, class T2, class C2>
755 inline typename MakeReturn<
756  BinaryNode<OpMod, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
757  Expression_t
758  operator%(const Expression<T1>& l, const Vector<T2, C2>& r)
759 {
760  typedef BinaryNode<OpMod, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
761  Tree_t;
762  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
763 }
764 
765 template<class T1, class T2, class C2>
766 inline typename MakeReturn<BinaryNode<OpBitwiseAnd,
767  typename CreateLeaf<Expression<T1>>::Leaf_t,
768  typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::Expression_t
769  operator&(const Expression<T1>& l, const Vector<T2, C2>& r)
770 {
771  typedef BinaryNode<OpBitwiseAnd, typename CreateLeaf<Expression<T1>>::Leaf_t,
772  typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
773  Tree_t;
774  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
775 }
776 
777 template<class T1, class T2, class C2>
778 inline typename MakeReturn<
779  BinaryNode<OpBitwiseOr, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
780  Expression_t
781  operator|(const Expression<T1>& l, const Vector<T2, C2>& r)
782 {
783  typedef BinaryNode<OpBitwiseOr, typename CreateLeaf<Expression<T1>>::Leaf_t,
784  typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
785  Tree_t;
786  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
787 }
788 
789 template<class T1, class T2, class C2>
790 inline typename MakeReturn<BinaryNode<OpBitwiseXor,
791  typename CreateLeaf<Expression<T1>>::Leaf_t,
792  typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::Expression_t
793  operator^(const Expression<T1>& l, const Vector<T2, C2>& r)
794 {
795  typedef BinaryNode<OpBitwiseXor, typename CreateLeaf<Expression<T1>>::Leaf_t,
796  typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
797  Tree_t;
798  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
799 }
800 
801 template<class T1, class T2, class C2>
802 inline typename MakeReturn<
803  BinaryNode<FnLdexp, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
804  Expression_t
805  ldexp(const Expression<T1>& l, const Vector<T2, C2>& r)
806 {
807  typedef BinaryNode<FnLdexp, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
808  Tree_t;
809  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
810 }
811 
812 template<class T1, class T2, class C2>
813 inline typename MakeReturn<
814  BinaryNode<FnPow, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
815  Expression_t
816  pow(const Expression<T1>& l, const Vector<T2, C2>& r)
817 {
818  typedef BinaryNode<FnPow, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
819  Tree_t;
820  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
821 }
822 
823 template<class T1, class T2, class C2>
824 inline typename MakeReturn<
825  BinaryNode<FnFmod, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
826  Expression_t
827  fmod(const Expression<T1>& l, const Vector<T2, C2>& r)
828 {
829  typedef BinaryNode<FnFmod, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
830  Tree_t;
831  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
832 }
833 
834 template<class T1, class T2, class C2>
835 inline typename MakeReturn<
836  BinaryNode<FnArcTan2, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
837  Expression_t
838  atan2(const Expression<T1>& l, const Vector<T2, C2>& r)
839 {
840  typedef BinaryNode<FnArcTan2, typename CreateLeaf<Expression<T1>>::Leaf_t,
841  typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
842  Tree_t;
843  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
844 }
845 
846 template<class T1, class T2, class C2>
847 inline typename MakeReturn<
848  BinaryNode<OpLT, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
849  Expression_t
850  operator<(const Expression<T1>& l, const Vector<T2, C2>& r)
851 {
852  typedef BinaryNode<OpLT, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
853  Tree_t;
854  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
855 }
856 
857 template<class T1, class T2, class C2>
858 inline typename MakeReturn<
859  BinaryNode<OpLE, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
860  Expression_t
861  operator<=(const Expression<T1>& l, const Vector<T2, C2>& r)
862 {
863  typedef BinaryNode<OpLE, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
864  Tree_t;
865  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
866 }
867 
868 template<class T1, class T2, class C2>
869 inline typename MakeReturn<
870  BinaryNode<OpGT, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
871  Expression_t
872  operator>(const Expression<T1>& l, const Vector<T2, C2>& r)
873 {
874  typedef BinaryNode<OpGT, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
875  Tree_t;
876  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
877 }
878 
879 template<class T1, class T2, class C2>
880 inline typename MakeReturn<
881  BinaryNode<OpGE, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
882  Expression_t
883  operator>=(const Expression<T1>& l, const Vector<T2, C2>& r)
884 {
885  typedef BinaryNode<OpGE, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
886  Tree_t;
887  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
888 }
889 
890 template<class T1, class T2, class C2>
891 inline typename MakeReturn<
892  BinaryNode<OpEQ, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
893  Expression_t
894  operator==(const Expression<T1>& l, const Vector<T2, C2>& r)
895 {
896  typedef BinaryNode<OpEQ, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
897  Tree_t;
898  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
899 }
900 
901 template<class T1, class T2, class C2>
902 inline typename MakeReturn<
903  BinaryNode<OpNE, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
904  Expression_t
905  operator!=(const Expression<T1>& l, const Vector<T2, C2>& r)
906 {
907  typedef BinaryNode<OpNE, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
908  Tree_t;
909  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
910 }
911 
912 template<class T1, class T2, class C2>
913 inline typename MakeReturn<
914  BinaryNode<OpAnd, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
915  Expression_t
916  operator&&(const Expression<T1>& l, const Vector<T2, C2>& r)
917 {
918  typedef BinaryNode<OpAnd, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
919  Tree_t;
920  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
921 }
922 
923 template<class T1, class T2, class C2>
924 inline typename MakeReturn<
925  BinaryNode<OpOr, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
926  Expression_t
927  operator||(const Expression<T1>& l, const Vector<T2, C2>& r)
928 {
929  typedef BinaryNode<OpOr, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
930  Tree_t;
931  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
932 }
933 
934 template<class T1, class T2, class C2>
935 inline typename MakeReturn<
936  BinaryNode<OpLeftShift, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
937  Expression_t
938  operator<<(const Expression<T1>& l, const Vector<T2, C2>& r)
939 {
940  typedef BinaryNode<OpLeftShift, typename CreateLeaf<Expression<T1>>::Leaf_t,
941  typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
942  Tree_t;
943  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
944 }
945 
946 template<class T1, class T2, class C2>
947 inline typename MakeReturn<BinaryNode<OpRightShift,
948  typename CreateLeaf<Expression<T1>>::Leaf_t,
949  typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::Expression_t
950  operator>>(const Expression<T1>& l, const Vector<T2, C2>& r)
951 {
952  typedef BinaryNode<OpRightShift, typename CreateLeaf<Expression<T1>>::Leaf_t,
953  typename CreateLeaf<Vector<T2, C2>>::Leaf_t>
954  Tree_t;
955  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
956 }
957 
958 template<class T1, class C1, class T2>
959 inline typename MakeReturn<
960  BinaryNode<OpAdd, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
961  operator+(const Vector<T1, C1>& l, const T2& r)
962 {
963  using Tree_t = BinaryNode<OpAdd, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
964  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
965 }
966 
967 template<class T1, class C1, class T2>
968 inline typename MakeReturn<
969  BinaryNode<OpSubtract, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
970  operator-(const Vector<T1, C1>& l, const T2& r)
971 {
972  using Tree_t = BinaryNode<OpSubtract, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
973  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
974 }
975 
976 template<class T1, class C1, class T2>
977 inline typename MakeReturn<
978  BinaryNode<OpMultiply, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
979  operator*(const Vector<T1, C1>& l, const T2& r)
980 {
981  using Tree_t = BinaryNode<OpMultiply, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
982  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
983 }
984 
985 template<class T1, class C1, class T2>
986 inline typename MakeReturn<
987  BinaryNode<OpDivide, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
988  operator/(const Vector<T1, C1>& l, const T2& r)
989 {
990  using Tree_t = BinaryNode<OpDivide, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
991  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
992 }
993 
994 template<class T1, class C1, class T2>
995 inline typename MakeReturn<
996  BinaryNode<OpMod, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
997  operator%(const Vector<T1, C1>& l, const T2& r)
998 {
999  using Tree_t = BinaryNode<OpMod, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1000  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
1001 }
1002 
1003 template<class T1, class C1, class T2>
1004 inline typename MakeReturn<
1005  BinaryNode<OpBitwiseAnd, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::
1006  Expression_t
1007  operator&(const Vector<T1, C1>& l, const T2& r)
1008 {
1009  using Tree_t = BinaryNode<OpBitwiseAnd, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1010  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
1011 }
1012 
1013 template<class T1, class C1, class T2>
1014 inline typename MakeReturn<
1015  BinaryNode<OpBitwiseOr, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1016  operator|(const Vector<T1, C1>& l, const T2& r)
1017 {
1018  using Tree_t = BinaryNode<OpBitwiseOr, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1019  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
1020 }
1021 
1022 template<class T1, class C1, class T2>
1023 inline typename MakeReturn<
1024  BinaryNode<OpBitwiseXor, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::
1025  Expression_t
1026  operator^(const Vector<T1, C1>& l, const T2& r)
1027 {
1028  using Tree_t = BinaryNode<OpBitwiseXor, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1029  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
1030 }
1031 
1032 template<class T1, class C1, class T2>
1033 inline typename MakeReturn<
1034  BinaryNode<FnLdexp, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1035  ldexp(const Vector<T1, C1>& l, const T2& r)
1036 {
1037  using Tree_t = BinaryNode<FnLdexp, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1038  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
1039 }
1040 
1041 template<class T1, class C1, class T2>
1042 inline typename MakeReturn<
1043  BinaryNode<FnPow, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1044  pow(const Vector<T1, C1>& l, const T2& r)
1045 {
1046  using Tree_t = BinaryNode<FnPow, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1047  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
1048 }
1049 
1050 template<class T1, class C1, class T2>
1051 inline typename MakeReturn<
1052  BinaryNode<FnFmod, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1053  fmod(const Vector<T1, C1>& l, const T2& r)
1054 {
1055  using Tree_t = BinaryNode<FnFmod, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1056  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
1057 }
1058 
1059 template<class T1, class C1, class T2>
1060 inline typename MakeReturn<
1061  BinaryNode<FnArcTan2, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1062  atan2(const Vector<T1, C1>& l, const T2& r)
1063 {
1064  using Tree_t = BinaryNode<FnArcTan2, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1065  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
1066 }
1067 
1068 template<class T1, class C1, class T2>
1069 inline typename MakeReturn<
1070  BinaryNode<OpLT, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1071  operator<(const Vector<T1, C1>& l, const T2& r)
1072 {
1073  using Tree_t = BinaryNode<OpLT, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1074  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
1075 }
1076 
1077 template<class T1, class C1, class T2>
1078 inline typename MakeReturn<
1079  BinaryNode<OpLE, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1080  operator<=(const Vector<T1, C1>& l, const T2& r)
1081 {
1082  using Tree_t = BinaryNode<OpLE, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1083  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
1084 }
1085 
1086 template<class T1, class C1, class T2>
1087 inline typename MakeReturn<
1088  BinaryNode<OpGT, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1089  operator>(const Vector<T1, C1>& l, const T2& r)
1090 {
1091  using Tree_t = BinaryNode<OpGT, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1092  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
1093 }
1094 
1095 template<class T1, class C1, class T2>
1096 inline typename MakeReturn<
1097  BinaryNode<OpGE, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1098  operator>=(const Vector<T1, C1>& l, const T2& r)
1099 {
1100  using Tree_t = BinaryNode<OpGE, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1101  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
1102 }
1103 
1104 template<class T1, class C1, class T2>
1105 inline typename MakeReturn<
1106  BinaryNode<OpEQ, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1107  operator==(const Vector<T1, C1>& l, const T2& r)
1108 {
1109  using Tree_t = BinaryNode<OpEQ, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1110  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
1111 }
1112 
1113 template<class T1, class C1, class T2>
1114 inline typename MakeReturn<
1115  BinaryNode<OpNE, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1116  operator!=(const Vector<T1, C1>& l, const T2& r)
1117 {
1118  using Tree_t = BinaryNode<OpNE, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1119  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
1120 }
1121 
1122 template<class T1, class C1, class T2>
1123 inline typename MakeReturn<
1124  BinaryNode<OpAnd, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1125  operator&&(const Vector<T1, C1>& l, const T2& r)
1126 {
1127  using Tree_t = BinaryNode<OpAnd, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1128  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
1129 }
1130 
1131 template<class T1, class C1, class T2>
1132 inline typename MakeReturn<
1133  BinaryNode<OpOr, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1134  operator||(const Vector<T1, C1>& l, const T2& r)
1135 {
1136  using Tree_t = BinaryNode<OpOr, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1137  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
1138 }
1139 
1140 template<class T1, class C1, class T2>
1141 inline typename MakeReturn<
1142  BinaryNode<OpLeftShift, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1143  operator<<(const Vector<T1, C1>& l, const T2& r)
1144 {
1145  using Tree_t = BinaryNode<OpLeftShift, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1146  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
1147 }
1148 
1149 template<class T1, class C1, class T2>
1150 inline typename MakeReturn<
1151  BinaryNode<OpRightShift, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::
1152  Expression_t
1153  operator>>(const Vector<T1, C1>& l, const T2& r)
1154 {
1155  using Tree_t = BinaryNode<OpRightShift, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1156  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Vector<T1, C1>>::make(l), CreateLeaf<T2>::make(r)));
1157 }
1158 
1159 template<class T1, class T2, class C2>
1160 inline typename MakeReturn<
1161  BinaryNode<OpAdd, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::Expression_t
1162  operator+(const T1& l, const Vector<T2, C2>& r)
1163 {
1164  using Tree_t = BinaryNode<OpAdd, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>;
1165  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
1166 }
1167 
1168 template<class T1, class T2, class C2>
1169 inline typename MakeReturn<
1170  BinaryNode<OpSubtract, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::Expression_t
1171  operator-(const T1& l, const Vector<T2, C2>& r)
1172 {
1173  using Tree_t = BinaryNode<OpSubtract, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>;
1174  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
1175 }
1176 
1177 template<class T1, class T2, class C2>
1178 inline typename MakeReturn<
1179  BinaryNode<OpMultiply, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::Expression_t
1180  operator*(const T1& l, const Vector<T2, C2>& r)
1181 {
1182  using Tree_t = BinaryNode<OpMultiply, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>;
1183  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
1184 }
1185 
1186 template<class T1, class T2, class C2>
1187 inline typename MakeReturn<
1188  BinaryNode<OpDivide, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::Expression_t
1189  operator/(const T1& l, const Vector<T2, C2>& r)
1190 {
1191  using Tree_t = BinaryNode<OpDivide, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>;
1192  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
1193 }
1194 
1195 template<class T1, class T2, class C2>
1196 inline typename MakeReturn<
1197  BinaryNode<OpMod, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::Expression_t
1198  operator%(const T1& l, const Vector<T2, C2>& r)
1199 {
1200  using Tree_t = BinaryNode<OpMod, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>;
1201  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
1202 }
1203 
1204 template<class T1, class T2, class C2>
1205 inline typename MakeReturn<
1206  BinaryNode<OpBitwiseAnd, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
1207  Expression_t
1208  operator&(const T1& l, const Vector<T2, C2>& r)
1209 {
1210  using Tree_t = BinaryNode<OpBitwiseAnd, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>;
1211  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
1212 }
1213 
1214 template<class T1, class T2, class C2>
1215 inline typename MakeReturn<
1216  BinaryNode<OpBitwiseOr, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::Expression_t
1217  operator|(const T1& l, const Vector<T2, C2>& r)
1218 {
1219  using Tree_t = BinaryNode<OpBitwiseOr, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>;
1220  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
1221 }
1222 
1223 template<class T1, class T2, class C2>
1224 inline typename MakeReturn<
1225  BinaryNode<OpBitwiseXor, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
1226  Expression_t
1227  operator^(const T1& l, const Vector<T2, C2>& r)
1228 {
1229  using Tree_t = BinaryNode<OpBitwiseXor, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>;
1230  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
1231 }
1232 
1233 template<class T1, class T2, class C2>
1234 inline typename MakeReturn<
1235  BinaryNode<FnLdexp, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::Expression_t
1236  ldexp(const T1& l, const Vector<T2, C2>& r)
1237 {
1238  using Tree_t = BinaryNode<FnLdexp, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>;
1239  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
1240 }
1241 
1242 template<class T1, class T2, class C2>
1243 inline typename MakeReturn<
1244  BinaryNode<FnPow, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::Expression_t
1245  pow(const T1& l, const Vector<T2, C2>& r)
1246 {
1247  using Tree_t = BinaryNode<FnPow, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>;
1248  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
1249 }
1250 
1251 template<class T1, class T2, class C2>
1252 inline typename MakeReturn<
1253  BinaryNode<FnFmod, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::Expression_t
1254  fmod(const T1& l, const Vector<T2, C2>& r)
1255 {
1256  using Tree_t = BinaryNode<FnFmod, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>;
1257  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
1258 }
1259 
1260 template<class T1, class T2, class C2>
1261 inline typename MakeReturn<
1262  BinaryNode<FnArcTan2, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::Expression_t
1263  atan2(const T1& l, const Vector<T2, C2>& r)
1264 {
1265  using Tree_t = BinaryNode<FnArcTan2, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>;
1266  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
1267 }
1268 
1269 template<class T1, class T2, class C2>
1270 inline typename MakeReturn<
1271  BinaryNode<OpLT, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::Expression_t
1272  operator<(const T1& l, const Vector<T2, C2>& r)
1273 {
1274  using Tree_t = BinaryNode<OpLT, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>;
1275  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
1276 }
1277 
1278 template<class T1, class T2, class C2>
1279 inline typename MakeReturn<
1280  BinaryNode<OpLE, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::Expression_t
1281  operator<=(const T1& l, const Vector<T2, C2>& r)
1282 {
1283  using Tree_t = BinaryNode<OpLE, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>;
1284  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
1285 }
1286 
1287 template<class T1, class T2, class C2>
1288 inline typename MakeReturn<
1289  BinaryNode<OpGT, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::Expression_t
1290  operator>(const T1& l, const Vector<T2, C2>& r)
1291 {
1292  using Tree_t = BinaryNode<OpGT, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>;
1293  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
1294 }
1295 
1296 template<class T1, class T2, class C2>
1297 inline typename MakeReturn<
1298  BinaryNode<OpGE, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::Expression_t
1299  operator>=(const T1& l, const Vector<T2, C2>& r)
1300 {
1301  using Tree_t = BinaryNode<OpGE, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>;
1302  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
1303 }
1304 
1305 template<class T1, class T2, class C2>
1306 inline typename MakeReturn<
1307  BinaryNode<OpEQ, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::Expression_t
1308  operator==(const T1& l, const Vector<T2, C2>& r)
1309 {
1310  using Tree_t = BinaryNode<OpEQ, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>;
1311  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
1312 }
1313 
1314 template<class T1, class T2, class C2>
1315 inline typename MakeReturn<
1316  BinaryNode<OpNE, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::Expression_t
1317  operator!=(const T1& l, const Vector<T2, C2>& r)
1318 {
1319  using Tree_t = BinaryNode<OpNE, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>;
1320  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
1321 }
1322 
1323 template<class T1, class T2, class C2>
1324 inline typename MakeReturn<
1325  BinaryNode<OpAnd, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::Expression_t
1326  operator&&(const T1& l, const Vector<T2, C2>& r)
1327 {
1328  using Tree_t = BinaryNode<OpAnd, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>;
1329  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
1330 }
1331 
1332 template<class T1, class T2, class C2>
1333 inline typename MakeReturn<
1334  BinaryNode<OpOr, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::Expression_t
1335  operator||(const T1& l, const Vector<T2, C2>& r)
1336 {
1337  using Tree_t = BinaryNode<OpOr, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>;
1338  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
1339 }
1340 #ifdef PETE_ALLOW_SCALAR_SHIFT
1341 
1342 template<class T1, class T2, class C2>
1343 inline typename MakeReturn<
1344  BinaryNode<OpLeftShift, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::Expression_t
1345  operator<<(const T1& l, const Vector<T2, C2>& r)
1346 {
1347  using Tree_t = BinaryNode<OpLeftShift, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>;
1348  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
1349 }
1350 
1351 template<class T1, class T2, class C2>
1352 inline typename MakeReturn<
1353  BinaryNode<OpRightShift, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>>::
1354  Expression_t
1355  operator>>(const T1& l, const Vector<T2, C2>& r)
1356 {
1357  using Tree_t = BinaryNode<OpRightShift, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Vector<T2, C2>>::Leaf_t>;
1358  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Vector<T2, C2>>::make(r)));
1359 }
1360 #endif // PETE_ALLOW_SCALAR_SHIFT
1361 
1362 template<class T1, class C1, class T2, class T3>
1363 inline typename MakeReturn<TrinaryNode<FnWhere,
1364  typename CreateLeaf<Vector<T1, C1>>::Leaf_t,
1365  typename CreateLeaf<T2>::Leaf_t,
1366  typename CreateLeaf<T3>::Leaf_t>>::Expression_t
1367  where(const Vector<T1, C1>& c, const T2& t, const T3& f)
1368 {
1369  typedef TrinaryNode<FnWhere, typename CreateLeaf<Vector<T1, C1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t,
1370  typename CreateLeaf<T3>::Leaf_t>
1371  Tree_t;
1372  return MakeReturn<Tree_t>::make(
1373  Tree_t(CreateLeaf<Vector<T1, C1>>::make(c), CreateLeaf<T2>::make(t), CreateLeaf<T3>::make(f)));
1374 }
1375 #ifndef PETE_EXPRESSION_OPERATORS
1376 #define PETE_EXPRESSION_OPERATORS
1377 
1378 template<class T1>
1379 inline typename MakeReturn<UnaryNode<FnArcCos, typename CreateLeaf<Expression<T1>>::Leaf_t>>::Expression_t acos(
1380  const Expression<T1>& l)
1381 {
1382  using Tree_t = UnaryNode<FnArcCos, typename CreateLeaf<Expression<T1>>::Leaf_t>;
1383  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l)));
1384 }
1385 
1386 template<class T1>
1387 inline typename MakeReturn<UnaryNode<FnArcSin, typename CreateLeaf<Expression<T1>>::Leaf_t>>::Expression_t asin(
1388  const Expression<T1>& l)
1389 {
1390  using Tree_t = UnaryNode<FnArcSin, typename CreateLeaf<Expression<T1>>::Leaf_t>;
1391  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l)));
1392 }
1393 
1394 template<class T1>
1395 inline typename MakeReturn<UnaryNode<FnArcTan, typename CreateLeaf<Expression<T1>>::Leaf_t>>::Expression_t atan(
1396  const Expression<T1>& l)
1397 {
1398  using Tree_t = UnaryNode<FnArcTan, typename CreateLeaf<Expression<T1>>::Leaf_t>;
1399  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l)));
1400 }
1401 
1402 template<class T1>
1403 inline typename MakeReturn<UnaryNode<FnCeil, typename CreateLeaf<Expression<T1>>::Leaf_t>>::Expression_t ceil(
1404  const Expression<T1>& l)
1405 {
1406  using Tree_t = UnaryNode<FnCeil, typename CreateLeaf<Expression<T1>>::Leaf_t>;
1407  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l)));
1408 }
1409 
1410 template<class T1>
1411 inline typename MakeReturn<UnaryNode<FnCos, typename CreateLeaf<Expression<T1>>::Leaf_t>>::Expression_t cos(
1412  const Expression<T1>& l)
1413 {
1414  using Tree_t = UnaryNode<FnCos, typename CreateLeaf<Expression<T1>>::Leaf_t>;
1415  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l)));
1416 }
1417 
1418 template<class T1>
1419 inline typename MakeReturn<UnaryNode<FnHypCos, typename CreateLeaf<Expression<T1>>::Leaf_t>>::Expression_t cosh(
1420  const Expression<T1>& l)
1421 {
1422  using Tree_t = UnaryNode<FnHypCos, typename CreateLeaf<Expression<T1>>::Leaf_t>;
1423  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l)));
1424 }
1425 
1426 template<class T1>
1427 inline typename MakeReturn<UnaryNode<FnExp, typename CreateLeaf<Expression<T1>>::Leaf_t>>::Expression_t exp(
1428  const Expression<T1>& l)
1429 {
1430  using Tree_t = UnaryNode<FnExp, typename CreateLeaf<Expression<T1>>::Leaf_t>;
1431  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l)));
1432 }
1433 
1434 template<class T1>
1435 inline typename MakeReturn<UnaryNode<FnFabs, typename CreateLeaf<Expression<T1>>::Leaf_t>>::Expression_t abs(
1436  const Expression<T1>& l)
1437 {
1438  using Tree_t = UnaryNode<FnFabs, typename CreateLeaf<Expression<T1>>::Leaf_t>;
1439  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l)));
1440 }
1441 
1442 template<class T1>
1443 inline typename MakeReturn<UnaryNode<FnFloor, typename CreateLeaf<Expression<T1>>::Leaf_t>>::Expression_t floor(
1444  const Expression<T1>& l)
1445 {
1446  using Tree_t = UnaryNode<FnFloor, typename CreateLeaf<Expression<T1>>::Leaf_t>;
1447  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l)));
1448 }
1449 
1450 template<class T1>
1451 inline typename MakeReturn<UnaryNode<FnLog, typename CreateLeaf<Expression<T1>>::Leaf_t>>::Expression_t log(
1452  const Expression<T1>& l)
1453 {
1454  using Tree_t = UnaryNode<FnLog, typename CreateLeaf<Expression<T1>>::Leaf_t>;
1455  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l)));
1456 }
1457 
1458 template<class T1>
1459 inline typename MakeReturn<UnaryNode<FnLog10, typename CreateLeaf<Expression<T1>>::Leaf_t>>::Expression_t log10(
1460  const Expression<T1>& l)
1461 {
1462  using Tree_t = UnaryNode<FnLog10, typename CreateLeaf<Expression<T1>>::Leaf_t>;
1463  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l)));
1464 }
1465 
1466 template<class T1>
1467 inline typename MakeReturn<UnaryNode<FnSin, typename CreateLeaf<Expression<T1>>::Leaf_t>>::Expression_t sin(
1468  const Expression<T1>& l)
1469 {
1470  using Tree_t = UnaryNode<FnSin, typename CreateLeaf<Expression<T1>>::Leaf_t>;
1471  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l)));
1472 }
1473 
1474 template<class T1>
1475 inline typename MakeReturn<UnaryNode<FnHypSin, typename CreateLeaf<Expression<T1>>::Leaf_t>>::Expression_t sinh(
1476  const Expression<T1>& l)
1477 {
1478  using Tree_t = UnaryNode<FnHypSin, typename CreateLeaf<Expression<T1>>::Leaf_t>;
1479  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l)));
1480 }
1481 
1482 template<class T1>
1483 inline typename MakeReturn<UnaryNode<FnSqrt, typename CreateLeaf<Expression<T1>>::Leaf_t>>::Expression_t sqrt(
1484  const Expression<T1>& l)
1485 {
1486  using Tree_t = UnaryNode<FnSqrt, typename CreateLeaf<Expression<T1>>::Leaf_t>;
1487  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l)));
1488 }
1489 
1490 template<class T1>
1491 inline typename MakeReturn<UnaryNode<FnTan, typename CreateLeaf<Expression<T1>>::Leaf_t>>::Expression_t tan(
1492  const Expression<T1>& l)
1493 {
1494  using Tree_t = UnaryNode<FnTan, typename CreateLeaf<Expression<T1>>::Leaf_t>;
1495  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l)));
1496 }
1497 
1498 template<class T1>
1499 inline typename MakeReturn<UnaryNode<FnHypTan, typename CreateLeaf<Expression<T1>>::Leaf_t>>::Expression_t tanh(
1500  const Expression<T1>& l)
1501 {
1502  using Tree_t = UnaryNode<FnHypTan, typename CreateLeaf<Expression<T1>>::Leaf_t>;
1503  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l)));
1504 }
1505 
1506 template<class T1>
1507 inline typename MakeReturn<UnaryNode<OpUnaryMinus, typename CreateLeaf<Expression<T1>>::Leaf_t>>::Expression_t
1508  operator-(const Expression<T1>& l)
1509 {
1510  using Tree_t = UnaryNode<OpUnaryMinus, typename CreateLeaf<Expression<T1>>::Leaf_t>;
1511  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l)));
1512 }
1513 
1514 template<class T1>
1515 inline typename MakeReturn<UnaryNode<OpUnaryPlus, typename CreateLeaf<Expression<T1>>::Leaf_t>>::Expression_t operator+(
1516  const Expression<T1>& l)
1517 {
1518  using Tree_t = UnaryNode<OpUnaryPlus, typename CreateLeaf<Expression<T1>>::Leaf_t>;
1519  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l)));
1520 }
1521 
1522 template<class T1>
1523 inline typename MakeReturn<UnaryNode<OpBitwiseNot, typename CreateLeaf<Expression<T1>>::Leaf_t>>::Expression_t
1524  operator~(const Expression<T1>& l)
1525 {
1526  using Tree_t = UnaryNode<OpBitwiseNot, typename CreateLeaf<Expression<T1>>::Leaf_t>;
1527  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l)));
1528 }
1529 
1530 template<class T1>
1531 inline typename MakeReturn<UnaryNode<OpIdentity, typename CreateLeaf<Expression<T1>>::Leaf_t>>::Expression_t
1532  PETE_identity(const Expression<T1>& l)
1533 {
1534  using Tree_t = UnaryNode<OpIdentity, typename CreateLeaf<Expression<T1>>::Leaf_t>;
1535  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l)));
1536 }
1537 
1538 template<class T1>
1539 inline typename MakeReturn<UnaryNode<OpNot, typename CreateLeaf<Expression<T1>>::Leaf_t>>::Expression_t operator!(
1540  const Expression<T1>& l)
1541 {
1542  using Tree_t = UnaryNode<OpNot, typename CreateLeaf<Expression<T1>>::Leaf_t>;
1543  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l)));
1544 }
1545 
1546 template<class T1, class T2>
1547 inline typename MakeReturn<UnaryNode<OpCast<T1>, typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t peteCast(
1548  const T1&,
1549  const Expression<T2>& l)
1550 {
1551  using Tree_t = UnaryNode<OpCast<T1>, typename CreateLeaf<Expression<T2>>::Leaf_t>;
1552  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T2>>::make(l)));
1553 }
1554 
1555 template<class T1, class T2>
1556 inline typename MakeReturn<
1557  BinaryNode<OpAdd, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
1558  Expression_t
1559  operator+(const Expression<T1>& l, const Expression<T2>& r)
1560 {
1561  typedef BinaryNode<OpAdd, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
1562  Tree_t;
1563  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
1564 }
1565 
1566 template<class T1, class T2>
1567 inline typename MakeReturn<
1568  BinaryNode<OpSubtract, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
1569  Expression_t
1570  operator-(const Expression<T1>& l, const Expression<T2>& r)
1571 {
1572  typedef BinaryNode<OpSubtract, typename CreateLeaf<Expression<T1>>::Leaf_t,
1573  typename CreateLeaf<Expression<T2>>::Leaf_t>
1574  Tree_t;
1575  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
1576 }
1577 
1578 template<class T1, class T2>
1579 inline typename MakeReturn<
1580  BinaryNode<OpMultiply, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
1581  Expression_t
1582  operator*(const Expression<T1>& l, const Expression<T2>& r)
1583 {
1584  typedef BinaryNode<OpMultiply, typename CreateLeaf<Expression<T1>>::Leaf_t,
1585  typename CreateLeaf<Expression<T2>>::Leaf_t>
1586  Tree_t;
1587  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
1588 }
1589 
1590 template<class T1, class T2>
1591 inline typename MakeReturn<
1592  BinaryNode<OpDivide, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
1593  Expression_t
1594  operator/(const Expression<T1>& l, const Expression<T2>& r)
1595 {
1596  typedef BinaryNode<OpDivide, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
1597  Tree_t;
1598  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
1599 }
1600 
1601 template<class T1, class T2>
1602 inline typename MakeReturn<
1603  BinaryNode<OpMod, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
1604  Expression_t
1605  operator%(const Expression<T1>& l, const Expression<T2>& r)
1606 {
1607  typedef BinaryNode<OpMod, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
1608  Tree_t;
1609  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
1610 }
1611 
1612 template<class T1, class T2>
1613 inline typename MakeReturn<BinaryNode<OpBitwiseAnd,
1614  typename CreateLeaf<Expression<T1>>::Leaf_t,
1615  typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
1616  operator&(const Expression<T1>& l, const Expression<T2>& r)
1617 {
1618  typedef BinaryNode<OpBitwiseAnd, typename CreateLeaf<Expression<T1>>::Leaf_t,
1619  typename CreateLeaf<Expression<T2>>::Leaf_t>
1620  Tree_t;
1621  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
1622 }
1623 
1624 template<class T1, class T2>
1625 inline typename MakeReturn<
1626  BinaryNode<OpBitwiseOr, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
1627  Expression_t
1628  operator|(const Expression<T1>& l, const Expression<T2>& r)
1629 {
1630  typedef BinaryNode<OpBitwiseOr, typename CreateLeaf<Expression<T1>>::Leaf_t,
1631  typename CreateLeaf<Expression<T2>>::Leaf_t>
1632  Tree_t;
1633  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
1634 }
1635 
1636 template<class T1, class T2>
1637 inline typename MakeReturn<BinaryNode<OpBitwiseXor,
1638  typename CreateLeaf<Expression<T1>>::Leaf_t,
1639  typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
1640  operator^(const Expression<T1>& l, const Expression<T2>& r)
1641 {
1642  typedef BinaryNode<OpBitwiseXor, typename CreateLeaf<Expression<T1>>::Leaf_t,
1643  typename CreateLeaf<Expression<T2>>::Leaf_t>
1644  Tree_t;
1645  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
1646 }
1647 
1648 template<class T1, class T2>
1649 inline typename MakeReturn<
1650  BinaryNode<FnLdexp, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
1651  Expression_t
1652  ldexp(const Expression<T1>& l, const Expression<T2>& r)
1653 {
1654  typedef BinaryNode<FnLdexp, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
1655  Tree_t;
1656  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
1657 }
1658 
1659 template<class T1, class T2>
1660 inline typename MakeReturn<
1661  BinaryNode<FnPow, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
1662  Expression_t
1663  pow(const Expression<T1>& l, const Expression<T2>& r)
1664 {
1665  typedef BinaryNode<FnPow, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
1666  Tree_t;
1667  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
1668 }
1669 
1670 template<class T1, class T2>
1671 inline typename MakeReturn<
1672  BinaryNode<FnFmod, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
1673  Expression_t
1674  fmod(const Expression<T1>& l, const Expression<T2>& r)
1675 {
1676  typedef BinaryNode<FnFmod, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
1677  Tree_t;
1678  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
1679 }
1680 
1681 template<class T1, class T2>
1682 inline typename MakeReturn<
1683  BinaryNode<FnArcTan2, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
1684  Expression_t
1685  atan2(const Expression<T1>& l, const Expression<T2>& r)
1686 {
1687  typedef BinaryNode<FnArcTan2, typename CreateLeaf<Expression<T1>>::Leaf_t,
1688  typename CreateLeaf<Expression<T2>>::Leaf_t>
1689  Tree_t;
1690  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
1691 }
1692 
1693 template<class T1, class T2>
1694 inline typename MakeReturn<
1695  BinaryNode<OpLT, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
1696  Expression_t
1697  operator<(const Expression<T1>& l, const Expression<T2>& r)
1698 {
1699  typedef BinaryNode<OpLT, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
1700  Tree_t;
1701  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
1702 }
1703 
1704 template<class T1, class T2>
1705 inline typename MakeReturn<
1706  BinaryNode<OpLE, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
1707  Expression_t
1708  operator<=(const Expression<T1>& l, const Expression<T2>& r)
1709 {
1710  typedef BinaryNode<OpLE, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
1711  Tree_t;
1712  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
1713 }
1714 
1715 template<class T1, class T2>
1716 inline typename MakeReturn<
1717  BinaryNode<OpGT, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
1718  Expression_t
1719  operator>(const Expression<T1>& l, const Expression<T2>& r)
1720 {
1721  typedef BinaryNode<OpGT, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
1722  Tree_t;
1723  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
1724 }
1725 
1726 template<class T1, class T2>
1727 inline typename MakeReturn<
1728  BinaryNode<OpGE, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
1729  Expression_t
1730  operator>=(const Expression<T1>& l, const Expression<T2>& r)
1731 {
1732  typedef BinaryNode<OpGE, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
1733  Tree_t;
1734  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
1735 }
1736 
1737 template<class T1, class T2>
1738 inline typename MakeReturn<
1739  BinaryNode<OpEQ, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
1740  Expression_t
1741  operator==(const Expression<T1>& l, const Expression<T2>& r)
1742 {
1743  typedef BinaryNode<OpEQ, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
1744  Tree_t;
1745  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
1746 }
1747 
1748 template<class T1, class T2>
1749 inline typename MakeReturn<
1750  BinaryNode<OpNE, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
1751  Expression_t
1752  operator!=(const Expression<T1>& l, const Expression<T2>& r)
1753 {
1754  typedef BinaryNode<OpNE, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
1755  Tree_t;
1756  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
1757 }
1758 
1759 template<class T1, class T2>
1760 inline typename MakeReturn<
1761  BinaryNode<OpAnd, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
1762  Expression_t
1763  operator&&(const Expression<T1>& l, const Expression<T2>& r)
1764 {
1765  typedef BinaryNode<OpAnd, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
1766  Tree_t;
1767  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
1768 }
1769 
1770 template<class T1, class T2>
1771 inline typename MakeReturn<
1772  BinaryNode<OpOr, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
1773  Expression_t
1774  operator||(const Expression<T1>& l, const Expression<T2>& r)
1775 {
1776  typedef BinaryNode<OpOr, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>
1777  Tree_t;
1778  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
1779 }
1780 
1781 template<class T1, class T2>
1782 inline typename MakeReturn<
1783  BinaryNode<OpLeftShift, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
1784  Expression_t
1785  operator<<(const Expression<T1>& l, const Expression<T2>& r)
1786 {
1787  typedef BinaryNode<OpLeftShift, typename CreateLeaf<Expression<T1>>::Leaf_t,
1788  typename CreateLeaf<Expression<T2>>::Leaf_t>
1789  Tree_t;
1790  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
1791 }
1792 
1793 template<class T1, class T2>
1794 inline typename MakeReturn<BinaryNode<OpRightShift,
1795  typename CreateLeaf<Expression<T1>>::Leaf_t,
1796  typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
1797  operator>>(const Expression<T1>& l, const Expression<T2>& r)
1798 {
1799  typedef BinaryNode<OpRightShift, typename CreateLeaf<Expression<T1>>::Leaf_t,
1800  typename CreateLeaf<Expression<T2>>::Leaf_t>
1801  Tree_t;
1802  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<Expression<T2>>::make(r)));
1803 }
1804 
1805 template<class T1, class T2>
1806 inline typename MakeReturn<
1807  BinaryNode<OpAdd, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1808  operator+(const Expression<T1>& l, const T2& r)
1809 {
1810  using Tree_t = BinaryNode<OpAdd, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1811  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
1812 }
1813 
1814 template<class T1, class T2>
1815 inline typename MakeReturn<
1816  BinaryNode<OpSubtract, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1817  operator-(const Expression<T1>& l, const T2& r)
1818 {
1819  using Tree_t = BinaryNode<OpSubtract, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1820  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
1821 }
1822 
1823 template<class T1, class T2>
1824 inline typename MakeReturn<
1825  BinaryNode<OpMultiply, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1826  operator*(const Expression<T1>& l, const T2& r)
1827 {
1828  using Tree_t = BinaryNode<OpMultiply, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1829  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
1830 }
1831 
1832 template<class T1, class T2>
1833 inline typename MakeReturn<
1834  BinaryNode<OpDivide, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1835  operator/(const Expression<T1>& l, const T2& r)
1836 {
1837  using Tree_t = BinaryNode<OpDivide, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1838  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
1839 }
1840 
1841 template<class T1, class T2>
1842 inline typename MakeReturn<
1843  BinaryNode<OpMod, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1844  operator%(const Expression<T1>& l, const T2& r)
1845 {
1846  using Tree_t = BinaryNode<OpMod, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1847  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
1848 }
1849 
1850 template<class T1, class T2>
1851 inline typename MakeReturn<
1852  BinaryNode<OpBitwiseAnd, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::
1853  Expression_t
1854  operator&(const Expression<T1>& l, const T2& r)
1855 {
1856  using Tree_t = BinaryNode<OpBitwiseAnd, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1857  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
1858 }
1859 
1860 template<class T1, class T2>
1861 inline typename MakeReturn<
1862  BinaryNode<OpBitwiseOr, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1863  operator|(const Expression<T1>& l, const T2& r)
1864 {
1865  using Tree_t = BinaryNode<OpBitwiseOr, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1866  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
1867 }
1868 
1869 template<class T1, class T2>
1870 inline typename MakeReturn<
1871  BinaryNode<OpBitwiseXor, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::
1872  Expression_t
1873  operator^(const Expression<T1>& l, const T2& r)
1874 {
1875  using Tree_t = BinaryNode<OpBitwiseXor, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1876  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
1877 }
1878 
1879 template<class T1, class T2>
1880 inline typename MakeReturn<
1881  BinaryNode<FnLdexp, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1882  ldexp(const Expression<T1>& l, const T2& r)
1883 {
1884  using Tree_t = BinaryNode<FnLdexp, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1885  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
1886 }
1887 
1888 template<class T1, class T2>
1889 inline typename MakeReturn<
1890  BinaryNode<FnPow, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1891  pow(const Expression<T1>& l, const T2& r)
1892 {
1893  using Tree_t = BinaryNode<FnPow, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1894  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
1895 }
1896 
1897 template<class T1, class T2>
1898 inline typename MakeReturn<
1899  BinaryNode<FnFmod, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1900  fmod(const Expression<T1>& l, const T2& r)
1901 {
1902  using Tree_t = BinaryNode<FnFmod, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1903  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
1904 }
1905 
1906 template<class T1, class T2>
1907 inline typename MakeReturn<
1908  BinaryNode<FnArcTan2, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1909  atan2(const Expression<T1>& l, const T2& r)
1910 {
1911  using Tree_t = BinaryNode<FnArcTan2, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1912  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
1913 }
1914 
1915 template<class T1, class T2>
1916 inline typename MakeReturn<
1917  BinaryNode<OpLT, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1918  operator<(const Expression<T1>& l, const T2& r)
1919 {
1920  using Tree_t = BinaryNode<OpLT, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1921  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
1922 }
1923 
1924 template<class T1, class T2>
1925 inline typename MakeReturn<
1926  BinaryNode<OpLE, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1927  operator<=(const Expression<T1>& l, const T2& r)
1928 {
1929  using Tree_t = BinaryNode<OpLE, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1930  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
1931 }
1932 
1933 template<class T1, class T2>
1934 inline typename MakeReturn<
1935  BinaryNode<OpGT, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1936  operator>(const Expression<T1>& l, const T2& r)
1937 {
1938  using Tree_t = BinaryNode<OpGT, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1939  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
1940 }
1941 
1942 template<class T1, class T2>
1943 inline typename MakeReturn<
1944  BinaryNode<OpGE, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1945  operator>=(const Expression<T1>& l, const T2& r)
1946 {
1947  using Tree_t = BinaryNode<OpGE, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1948  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
1949 }
1950 
1951 template<class T1, class T2>
1952 inline typename MakeReturn<
1953  BinaryNode<OpEQ, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1954  operator==(const Expression<T1>& l, const T2& r)
1955 {
1956  using Tree_t = BinaryNode<OpEQ, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1957  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
1958 }
1959 
1960 template<class T1, class T2>
1961 inline typename MakeReturn<
1962  BinaryNode<OpNE, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1963  operator!=(const Expression<T1>& l, const T2& r)
1964 {
1965  using Tree_t = BinaryNode<OpNE, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1966  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
1967 }
1968 
1969 template<class T1, class T2>
1970 inline typename MakeReturn<
1971  BinaryNode<OpAnd, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1972  operator&&(const Expression<T1>& l, const T2& r)
1973 {
1974  using Tree_t = BinaryNode<OpAnd, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1975  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
1976 }
1977 
1978 template<class T1, class T2>
1979 inline typename MakeReturn<
1980  BinaryNode<OpOr, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1981  operator||(const Expression<T1>& l, const T2& r)
1982 {
1983  using Tree_t = BinaryNode<OpOr, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1984  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
1985 }
1986 
1987 template<class T1, class T2>
1988 inline typename MakeReturn<
1989  BinaryNode<OpLeftShift, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::Expression_t
1990  operator<<(const Expression<T1>& l, const T2& r)
1991 {
1992  using Tree_t = BinaryNode<OpLeftShift, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
1993  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
1994 }
1995 
1996 template<class T1, class T2>
1997 inline typename MakeReturn<
1998  BinaryNode<OpRightShift, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>>::
1999  Expression_t
2000  operator>>(const Expression<T1>& l, const T2& r)
2001 {
2002  using Tree_t = BinaryNode<OpRightShift, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t>;
2003  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<Expression<T1>>::make(l), CreateLeaf<T2>::make(r)));
2004 }
2005 
2006 template<class T1, class T2>
2007 inline typename MakeReturn<
2008  BinaryNode<OpAdd, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
2009  operator+(const T1& l, const Expression<T2>& r)
2010 {
2011  using Tree_t = BinaryNode<OpAdd, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
2012  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
2013 }
2014 
2015 template<class T1, class T2>
2016 inline typename MakeReturn<
2017  BinaryNode<OpSubtract, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
2018  operator-(const T1& l, const Expression<T2>& r)
2019 {
2020  using Tree_t = BinaryNode<OpSubtract, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
2021  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
2022 }
2023 
2024 template<class T1, class T2>
2025 inline typename MakeReturn<
2026  BinaryNode<OpMultiply, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
2027  operator*(const T1& l, const Expression<T2>& r)
2028 {
2029  using Tree_t = BinaryNode<OpMultiply, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
2030  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
2031 }
2032 
2033 template<class T1, class T2>
2034 inline typename MakeReturn<
2035  BinaryNode<OpDivide, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
2036  operator/(const T1& l, const Expression<T2>& r)
2037 {
2038  using Tree_t = BinaryNode<OpDivide, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
2039  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
2040 }
2041 
2042 template<class T1, class T2>
2043 inline typename MakeReturn<
2044  BinaryNode<OpMod, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
2045  operator%(const T1& l, const Expression<T2>& r)
2046 {
2047  using Tree_t = BinaryNode<OpMod, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
2048  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
2049 }
2050 
2051 template<class T1, class T2>
2052 inline typename MakeReturn<
2053  BinaryNode<OpBitwiseAnd, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
2054  Expression_t
2055  operator&(const T1& l, const Expression<T2>& r)
2056 {
2057  using Tree_t = BinaryNode<OpBitwiseAnd, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
2058  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
2059 }
2060 
2061 template<class T1, class T2>
2062 inline typename MakeReturn<
2063  BinaryNode<OpBitwiseOr, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
2064  operator|(const T1& l, const Expression<T2>& r)
2065 {
2066  using Tree_t = BinaryNode<OpBitwiseOr, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
2067  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
2068 }
2069 
2070 template<class T1, class T2>
2071 inline typename MakeReturn<
2072  BinaryNode<OpBitwiseXor, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
2073  Expression_t
2074  operator^(const T1& l, const Expression<T2>& r)
2075 {
2076  using Tree_t = BinaryNode<OpBitwiseXor, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
2077  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
2078 }
2079 
2080 template<class T1, class T2>
2081 inline typename MakeReturn<
2082  BinaryNode<FnLdexp, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
2083  ldexp(const T1& l, const Expression<T2>& r)
2084 {
2085  using Tree_t = BinaryNode<FnLdexp, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
2086  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
2087 }
2088 
2089 template<class T1, class T2>
2090 inline typename MakeReturn<
2091  BinaryNode<FnPow, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
2092  pow(const T1& l, const Expression<T2>& r)
2093 {
2094  using Tree_t = BinaryNode<FnPow, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
2095  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
2096 }
2097 
2098 template<class T1, class T2>
2099 inline typename MakeReturn<
2100  BinaryNode<FnFmod, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
2101  fmod(const T1& l, const Expression<T2>& r)
2102 {
2103  using Tree_t = BinaryNode<FnFmod, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
2104  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
2105 }
2106 
2107 template<class T1, class T2>
2108 inline typename MakeReturn<
2109  BinaryNode<FnArcTan2, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
2110  atan2(const T1& l, const Expression<T2>& r)
2111 {
2112  using Tree_t = BinaryNode<FnArcTan2, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
2113  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
2114 }
2115 
2116 template<class T1, class T2>
2117 inline typename MakeReturn<
2118  BinaryNode<OpLT, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
2119  operator<(const T1& l, const Expression<T2>& r)
2120 {
2121  using Tree_t = BinaryNode<OpLT, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
2122  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
2123 }
2124 
2125 template<class T1, class T2>
2126 inline typename MakeReturn<
2127  BinaryNode<OpLE, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
2128  operator<=(const T1& l, const Expression<T2>& r)
2129 {
2130  using Tree_t = BinaryNode<OpLE, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
2131  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
2132 }
2133 
2134 template<class T1, class T2>
2135 inline typename MakeReturn<
2136  BinaryNode<OpGT, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
2137  operator>(const T1& l, const Expression<T2>& r)
2138 {
2139  using Tree_t = BinaryNode<OpGT, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
2140  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
2141 }
2142 
2143 template<class T1, class T2>
2144 inline typename MakeReturn<
2145  BinaryNode<OpGE, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
2146  operator>=(const T1& l, const Expression<T2>& r)
2147 {
2148  using Tree_t = BinaryNode<OpGE, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
2149  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
2150 }
2151 
2152 template<class T1, class T2>
2153 inline typename MakeReturn<
2154  BinaryNode<OpEQ, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
2155  operator==(const T1& l, const Expression<T2>& r)
2156 {
2157  using Tree_t = BinaryNode<OpEQ, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
2158  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
2159 }
2160 
2161 template<class T1, class T2>
2162 inline typename MakeReturn<
2163  BinaryNode<OpNE, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
2164  operator!=(const T1& l, const Expression<T2>& r)
2165 {
2166  using Tree_t = BinaryNode<OpNE, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
2167  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
2168 }
2169 
2170 template<class T1, class T2>
2171 inline typename MakeReturn<
2172  BinaryNode<OpAnd, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
2173  operator&&(const T1& l, const Expression<T2>& r)
2174 {
2175  using Tree_t = BinaryNode<OpAnd, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
2176  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
2177 }
2178 
2179 template<class T1, class T2>
2180 inline typename MakeReturn<
2181  BinaryNode<OpOr, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
2182  operator||(const T1& l, const Expression<T2>& r)
2183 {
2184  using Tree_t = BinaryNode<OpOr, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
2185  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
2186 }
2187 #ifdef PETE_ALLOW_SCALAR_SHIFT
2188 
2189 template<class T1, class T2>
2190 inline typename MakeReturn<
2191  BinaryNode<OpLeftShift, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::Expression_t
2192  operator<<(const T1& l, const Expression<T2>& r)
2193 {
2194  using Tree_t = BinaryNode<OpLeftShift, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
2195  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
2196 }
2197 
2198 template<class T1, class T2>
2199 inline typename MakeReturn<
2200  BinaryNode<OpRightShift, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>>::
2201  Expression_t
2202  operator>>(const T1& l, const Expression<T2>& r)
2203 {
2204  using Tree_t = BinaryNode<OpRightShift, typename CreateLeaf<T1>::Leaf_t, typename CreateLeaf<Expression<T2>>::Leaf_t>;
2205  return MakeReturn<Tree_t>::make(Tree_t(CreateLeaf<T1>::make(l), CreateLeaf<Expression<T2>>::make(r)));
2206 }
2207 #endif // PETE_ALLOW_SCALAR_SHIFT
2208 
2209 template<class T1, class T2, class T3>
2210 inline typename MakeReturn<TrinaryNode<FnWhere,
2211  typename CreateLeaf<Expression<T1>>::Leaf_t,
2212  typename CreateLeaf<T2>::Leaf_t,
2213  typename CreateLeaf<T3>::Leaf_t>>::Expression_t
2214  where(const Expression<T1>& c, const T2& t, const T3& f)
2215 {
2216  typedef TrinaryNode<FnWhere, typename CreateLeaf<Expression<T1>>::Leaf_t, typename CreateLeaf<T2>::Leaf_t,
2217  typename CreateLeaf<T3>::Leaf_t>
2218  Tree_t;
2219  return MakeReturn<Tree_t>::make(
2220  Tree_t(CreateLeaf<Expression<T1>>::make(c), CreateLeaf<T2>::make(t), CreateLeaf<T3>::make(f)));
2221 }
2222 #endif // PETE_EXPRESSION_OPERATORS
2223 
2224 template<class T1, class C1, class RHS>
2225 inline Vector<T1, C1>& assign(Vector<T1, C1>& lhs, const RHS& rhs)
2226 {
2227  using Leaf_t = typename CreateLeaf<RHS>::Leaf_t;
2228  evaluate(lhs, OpAssign(), MakeReturn<Leaf_t>::make(CreateLeaf<RHS>::make(rhs)));
2229  return lhs;
2230 }
2231 
2232 template<class T1, class C1, class RHS>
2233 inline Vector<T1, C1>& operator+=(Vector<T1, C1>& lhs, const RHS& rhs)
2234 {
2235  using Leaf_t = typename CreateLeaf<RHS>::Leaf_t;
2236  evaluate(lhs, OpAddAssign(), MakeReturn<Leaf_t>::make(CreateLeaf<RHS>::make(rhs)));
2237  return lhs;
2238 }
2239 
2240 template<class T1, class C1, class RHS>
2241 inline Vector<T1, C1>& operator-=(Vector<T1, C1>& lhs, const RHS& rhs)
2242 {
2243  using Leaf_t = typename CreateLeaf<RHS>::Leaf_t;
2244  evaluate(lhs, OpSubtractAssign(), MakeReturn<Leaf_t>::make(CreateLeaf<RHS>::make(rhs)));
2245  return lhs;
2246 }
2247 
2248 template<class T1, class C1, class RHS>
2249 inline Vector<T1, C1>& operator*=(Vector<T1, C1>& lhs, const RHS& rhs)
2250 {
2251  using Leaf_t = typename CreateLeaf<RHS>::Leaf_t;
2252  evaluate(lhs, OpMultiplyAssign(), MakeReturn<Leaf_t>::make(CreateLeaf<RHS>::make(rhs)));
2253  return lhs;
2254 }
2255 
2256 template<class T1, class C1, class RHS>
2257 inline Vector<T1, C1>& operator/=(Vector<T1, C1>& lhs, const RHS& rhs)
2258 {
2259  using Leaf_t = typename CreateLeaf<RHS>::Leaf_t;
2260  evaluate(lhs, OpDivideAssign(), MakeReturn<Leaf_t>::make(CreateLeaf<RHS>::make(rhs)));
2261  return lhs;
2262 }
2263 
2264 template<class T1, class C1, class RHS>
2265 inline Vector<T1, C1>& operator%=(Vector<T1, C1>& lhs, const RHS& rhs)
2266 {
2267  using Leaf_t = typename CreateLeaf<RHS>::Leaf_t;
2268  evaluate(lhs, OpModAssign(), MakeReturn<Leaf_t>::make(CreateLeaf<RHS>::make(rhs)));
2269  return lhs;
2270 }
2271 
2272 template<class T1, class C1, class RHS>
2273 inline Vector<T1, C1>& operator|=(Vector<T1, C1>& lhs, const RHS& rhs)
2274 {
2275  using Leaf_t = typename CreateLeaf<RHS>::Leaf_t;
2276  evaluate(lhs, OpBitwiseOrAssign(), MakeReturn<Leaf_t>::make(CreateLeaf<RHS>::make(rhs)));
2277  return lhs;
2278 }
2279 
2280 template<class T1, class C1, class RHS>
2281 inline Vector<T1, C1>& operator&=(Vector<T1, C1>& lhs, const RHS& rhs)
2282 {
2283  using Leaf_t = typename CreateLeaf<RHS>::Leaf_t;
2284  evaluate(lhs, OpBitwiseAndAssign(), MakeReturn<Leaf_t>::make(CreateLeaf<RHS>::make(rhs)));
2285  return lhs;
2286 }
2287 
2288 template<class T1, class C1, class RHS>
2289 inline Vector<T1, C1>& operator^=(Vector<T1, C1>& lhs, const RHS& rhs)
2290 {
2291  using Leaf_t = typename CreateLeaf<RHS>::Leaf_t;
2292  evaluate(lhs, OpBitwiseXorAssign(), MakeReturn<Leaf_t>::make(CreateLeaf<RHS>::make(rhs)));
2293  return lhs;
2294 }
2295 
2296 template<class T1, class C1, class RHS>
2297 inline Vector<T1, C1>& operator<<=(Vector<T1, C1>& lhs, const RHS& rhs)
2298 {
2299  using Leaf_t = typename CreateLeaf<RHS>::Leaf_t;
2300  evaluate(lhs, OpLeftShiftAssign(), MakeReturn<Leaf_t>::make(CreateLeaf<RHS>::make(rhs)));
2301  return lhs;
2302 }
2303 
2304 template<class T1, class C1, class RHS>
2305 inline Vector<T1, C1>& operator>>=(Vector<T1, C1>& lhs, const RHS& rhs)
2306 {
2307  using Leaf_t = typename CreateLeaf<RHS>::Leaf_t;
2308  evaluate(lhs, OpRightShiftAssign(), MakeReturn<Leaf_t>::make(CreateLeaf<RHS>::make(rhs)));
2309  return lhs;
2310 }
2311 
2312 } // namespace qmcplusplus
2313 
2314 #endif // GENERATED_OPERATORS_H
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
qmcplusplus::sinh
MakeReturn< UnaryNode< FnHypSin, typename CreateLeaf< Vector< T1, C1 > >::Leaf_t > >::Expression_t sinh(const Vector< T1, C1 > &l)
Definition: OhmmsVectorOperators.h:128
qmcplusplus::fmod
MakeReturn< BinaryNode< FnFmod, typename CreateLeaf< Vector< T1, C1 > >::Leaf_t, typename CreateLeaf< Vector< T2, C2 > >::Leaf_t > >::Expression_t fmod(const Vector< T1, C1 > &l, const Vector< T2, C2 > &r)
Definition: OhmmsVectorOperators.h:327
Scalar
Definition: Scalar.h:49
qmcplusplus::abs
MakeReturn< UnaryNode< FnFabs, typename CreateLeaf< Vector< T1, C1 > >::Leaf_t > >::Expression_t abs(const Vector< T1, C1 > &l)
Definition: OhmmsVectorOperators.h:88
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< BinaryNode< OpGE, typename CreateLeaf< Vector< T1, C1 > >::Leaf_t, typename CreateLeaf< Vector< T2, C2 > >::Leaf_t > >::Expression_t operator>=(const Vector< T1, C1 > &l, const Vector< T2, C2 > &r)
Definition: OhmmsVectorOperators.h:383
qmcplusplus::ldexp
MakeReturn< BinaryNode< FnLdexp, typename CreateLeaf< Vector< T1, C1 > >::Leaf_t, typename CreateLeaf< Vector< T2, C2 > >::Leaf_t > >::Expression_t ldexp(const Vector< T1, C1 > &l, const Vector< T2, C2 > &r)
Definition: OhmmsVectorOperators.h:305
qmcplusplus::sin
MakeReturn< UnaryNode< FnSin, typename CreateLeaf< Vector< T1, C1 > >::Leaf_t > >::Expression_t sin(const Vector< T1, C1 > &l)
Definition: OhmmsVectorOperators.h:120
qmcplusplus::operator==
bool operator==(const Matrix< T, Alloc > &lhs, const Matrix< T, Alloc > &rhs)
Definition: OhmmsMatrix.h:388
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::cosh
MakeReturn< UnaryNode< FnHypCos, typename CreateLeaf< Vector< T1, C1 > >::Leaf_t > >::Expression_t cosh(const Vector< T1, C1 > &l)
Definition: OhmmsVectorOperators.h:72
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::pow
MakeReturn< BinaryNode< FnPow, typename CreateLeaf< Vector< T1, C1 > >::Leaf_t, typename CreateLeaf< Vector< T2, C2 > >::Leaf_t > >::Expression_t pow(const Vector< T1, C1 > &l, const Vector< T2, C2 > &r)
Definition: OhmmsVectorOperators.h:316
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::CreateLeaf::make
static Leaf_t make(const T &a)
Definition: CreateLeaf.h:97
qmcplusplus::tanh
MakeReturn< UnaryNode< FnHypTan, typename CreateLeaf< Vector< T1, C1 > >::Leaf_t > >::Expression_t tanh(const Vector< T1, C1 > &l)
Definition: OhmmsVectorOperators.h:152
qmcplusplus::cos
MakeReturn< UnaryNode< FnCos, typename CreateLeaf< Vector< T1, C1 > >::Leaf_t > >::Expression_t cos(const Vector< T1, C1 > &l)
Definition: OhmmsVectorOperators.h:64
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::ceil
MakeReturn< UnaryNode< FnCeil, typename CreateLeaf< Vector< T1, C1 > >::Leaf_t > >::Expression_t ceil(const Vector< T1, C1 > &l)
Definition: OhmmsVectorOperators.h:56
qmcplusplus::acos
MakeReturn< UnaryNode< FnArcCos, typename CreateLeaf< Vector< T1, C1 > >::Leaf_t > >::Expression_t acos(const Vector< T1, C1 > &l)
Definition: OhmmsVectorOperators.h:32
qmcplusplus::atan2
MakeReturn< BinaryNode< FnArcTan2, typename CreateLeaf< Vector< T1, C1 > >::Leaf_t, typename CreateLeaf< Vector< T2, C2 > >::Leaf_t > >::Expression_t atan2(const Vector< T1, C1 > &l, const Vector< T2, C2 > &r)
Definition: OhmmsVectorOperators.h:338
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::atan
MakeReturn< UnaryNode< FnArcTan, typename CreateLeaf< Vector< T1, C1 > >::Leaf_t > >::Expression_t atan(const Vector< T1, C1 > &l)
Definition: OhmmsVectorOperators.h:48
qmcplusplus::operator &&
MakeReturn< BinaryNode< OpAnd, typename CreateLeaf< Vector< T1, C1 > >::Leaf_t, typename CreateLeaf< Vector< T2, C2 > >::Leaf_t > >::Expression_t operator &&(const Vector< T1, C1 > &l, const Vector< T2, C2 > &r)
Definition: OhmmsVectorOperators.h:416
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>>=
Vector< T1, C1 > & operator>>=(Vector< T1, C1 > &lhs, const RHS &rhs)
Definition: OhmmsVectorOperators.h:2305
qmcplusplus::operator>
MakeReturn< BinaryNode< OpGT, typename CreateLeaf< Vector< T1, C1 > >::Leaf_t, typename CreateLeaf< Vector< T2, C2 > >::Leaf_t > >::Expression_t operator>(const Vector< T1, C1 > &l, const Vector< T2, C2 > &r)
Definition: OhmmsVectorOperators.h:372
qmcplusplus::exp
MakeReturn< UnaryNode< FnExp, typename CreateLeaf< Vector< T1, C1 > >::Leaf_t > >::Expression_t exp(const Vector< T1, C1 > &l)
Definition: OhmmsVectorOperators.h:80
qmcplusplus::tan
MakeReturn< UnaryNode< FnTan, typename CreateLeaf< Vector< T1, C1 > >::Leaf_t > >::Expression_t tan(const Vector< T1, C1 > &l)
Definition: OhmmsVectorOperators.h:144
qmcplusplus::log10
MakeReturn< UnaryNode< FnLog10, typename CreateLeaf< Vector< T1, C1 > >::Leaf_t > >::Expression_t log10(const Vector< T1, C1 > &l)
Definition: OhmmsVectorOperators.h:112
qmcplusplus::operator*=
Matrix< T1, C1 > & operator*=(Matrix< T1, C1 > &lhs, const RHS &rhs)
Definition: OhmmsMatrixOperators.h:760
qmcplusplus::operator/=
Vector< T1, C1 > & operator/=(Vector< T1, C1 > &lhs, const RHS &rhs)
Definition: OhmmsVectorOperators.h:2257
qmcplusplus::log
MakeReturn< UnaryNode< FnLog, typename CreateLeaf< Vector< T1, C1 > >::Leaf_t > >::Expression_t log(const Vector< T1, C1 > &l)
Definition: OhmmsVectorOperators.h:104
qmcplusplus::sqrt
MakeReturn< UnaryNode< FnSqrt, typename CreateLeaf< Vector< T1, C1 > >::Leaf_t > >::Expression_t sqrt(const Vector< T1, C1 > &l)
Definition: OhmmsVectorOperators.h:136
qmcplusplus::operator!
MakeReturn< UnaryNode< OpNot, typename CreateLeaf< Vector< T1, C1 > >::Leaf_t > >::Expression_t operator!(const Vector< T1, C1 > &l)
Definition: OhmmsVectorOperators.h:192
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::operator||
MakeReturn< BinaryNode< OpOr, typename CreateLeaf< Vector< T1, C1 > >::Leaf_t, typename CreateLeaf< Vector< T2, C2 > >::Leaf_t > >::Expression_t operator||(const Vector< T1, C1 > &l, const Vector< T2, C2 > &r)
Definition: OhmmsVectorOperators.h:427
qmcplusplus::operator>>
std::istream & operator>>(std::istream &is, Matrix< T, Alloc > &rhs)
Definition: OhmmsMatrix.h:427
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< OpDivide, typename CreateLeaf< Vector< T1, C1 > >::Leaf_t, typename CreateLeaf< Vector< T2, C2 > >::Leaf_t > >::Expression_t operator/(const Vector< T1, C1 > &l, const Vector< T2, C2 > &r)
Definition: OhmmsVectorOperators.h:247
qmcplusplus::operator!=
bool operator!=(const Matrix< T, Alloc > &lhs, const Matrix< T, Alloc > &rhs)
Definition: OhmmsMatrix.h:403
qmcplusplus::asin
MakeReturn< UnaryNode< FnArcSin, typename CreateLeaf< Vector< T1, C1 > >::Leaf_t > >::Expression_t asin(const Vector< T1, C1 > &l)
Definition: OhmmsVectorOperators.h:40
qmcplusplus::floor
MakeReturn< UnaryNode< FnFloor, typename CreateLeaf< Vector< T1, C1 > >::Leaf_t > >::Expression_t floor(const Vector< T1, C1 > &l)
Definition: OhmmsVectorOperators.h:96
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