rheolef  6.5
vec_expr_ops.h
Go to the documentation of this file.
1 #ifndef _RHEOLEF_VEC_EXPR_OPS_H
2 #define _RHEOLEF_VEC_EXPR_OPS_H
3 // do not edit !
4 // ./vec_expr_ops_make > vec_expr_ops.h
5 // Rheolef is free software; you can redistribute it and/or modify
6 #include "rheolef/promote.h"
7 #include "rheolef/vec_expr.h"
8 namespace rheolef {
9 template<class T, class M>
10 #if BOOST_VERSION < 104601
11 typename boost::proto::detail::enable_unary<
12  vec_domain,
13  is_vec<vec<T,M> >,
14  vec<T,M>,
15  typename boost::proto::functional::make_expr<boost::proto::tag::unary_plus, vec_domain>
16  ::impl<const vec<T,M>&>::result_type
17  >::type const
18 operator+ (const vec<T,M>& arg)
19 {
20  return boost::proto::functional::make_expr<boost::proto::tag::unary_plus, vec_domain>
21  ::impl<const vec<T,M>&>()(arg);
22 }
23 #else // BOOST_VERSION >= 104601
24 typename boost::proto::detail::enable_unary<
25  vec_domain,
26  vec_domain::proto_grammar,
27  boost::mpl::and_<
28  is_vec<vec<T,M> >,
29  boost::mpl::not_<boost::proto::is_extension<vec<T,M> > >
30  >,
31  boost::proto::tag::unary_plus,
32  vec<T,M> const &
33 >::type const
34 operator+ (const vec<T,M>& arg)
35 {
36  return boost::proto::detail::make_expr_<boost::proto::tag::unary_plus, vec_domain, vec<T,M> const &>()(arg);
37 }
38 #endif // BOOST_VERSION
39 template<class Expr>
40 #if BOOST_VERSION < 104601
41 typename boost::proto::detail::enable_unary<
42  vec_domain,
43  is_vec<vec_expr<Expr> >,
44  vec_expr<Expr>,
45  typename boost::proto::functional::make_expr<boost::proto::tag::unary_plus, vec_domain>
46  ::impl<const vec_expr<Expr>&>::result_type
47  >::type const
49 {
50  return boost::proto::functional::make_expr<boost::proto::tag::unary_plus, vec_domain>
51  ::impl<const vec_expr<Expr>&>()(arg);
52 }
53 #else // BOOST_VERSION >= 104601
54 typename boost::proto::detail::enable_unary<
55  vec_domain,
56  vec_domain::proto_grammar,
57  boost::mpl::and_<
58  is_vec<vec_expr<Expr> >,
59  boost::mpl::not_<boost::proto::is_extension<vec_expr<Expr> > >
60  >,
61  boost::proto::tag::unary_plus,
62  vec_expr<Expr> const &
63 >::type const
64 operator+ (const vec_expr<Expr>& arg)
65 {
66  return boost::proto::detail::make_expr_<boost::proto::tag::unary_plus, vec_domain, vec_expr<Expr> const &>()(arg);
67 }
68 #endif // BOOST_VERSION
69 template<class T, class M>
70 #if BOOST_VERSION < 104601
71 typename boost::proto::detail::enable_unary<
72  vec_domain,
73  is_vec<vec<T,M> >,
74  vec<T,M>,
75  typename boost::proto::functional::make_expr<boost::proto::tag::negate, vec_domain>
76  ::impl<const vec<T,M>&>::result_type
77  >::type const
78 operator- (const vec<T,M>& arg)
79 {
80  return boost::proto::functional::make_expr<boost::proto::tag::negate, vec_domain>
81  ::impl<const vec<T,M>&>()(arg);
82 }
83 #else // BOOST_VERSION >= 104601
84 typename boost::proto::detail::enable_unary<
85  vec_domain,
86  vec_domain::proto_grammar,
87  boost::mpl::and_<
88  is_vec<vec<T,M> >,
89  boost::mpl::not_<boost::proto::is_extension<vec<T,M> > >
90  >,
91  boost::proto::tag::negate,
92  vec<T,M> const &
93 >::type const
94 operator- (const vec<T,M>& arg)
95 {
96  return boost::proto::detail::make_expr_<boost::proto::tag::negate, vec_domain, vec<T,M> const &>()(arg);
97 }
98 #endif // BOOST_VERSION
99 template<class Expr>
100 #if BOOST_VERSION < 104601
101 typename boost::proto::detail::enable_unary<
102  vec_domain,
103  is_vec<vec_expr<Expr> >,
104  vec_expr<Expr>,
105  typename boost::proto::functional::make_expr<boost::proto::tag::negate, vec_domain>
106  ::impl<const vec_expr<Expr>&>::result_type
107  >::type const
109 {
110  return boost::proto::functional::make_expr<boost::proto::tag::negate, vec_domain>
111  ::impl<const vec_expr<Expr>&>()(arg);
112 }
113 #else // BOOST_VERSION >= 104601
114 typename boost::proto::detail::enable_unary<
115  vec_domain,
116  vec_domain::proto_grammar,
117  boost::mpl::and_<
118  is_vec<vec_expr<Expr> >,
119  boost::mpl::not_<boost::proto::is_extension<vec_expr<Expr> > >
120  >,
121  boost::proto::tag::negate,
122  vec_expr<Expr> const &
123 >::type const
124 operator- (const vec_expr<Expr>& arg)
125 {
126  return boost::proto::detail::make_expr_<boost::proto::tag::negate, vec_domain, vec_expr<Expr> const &>()(arg);
127 }
128 #endif // BOOST_VERSION
129 template<class T, class M>
130 #if BOOST_VERSION < 104601
131 typename
132 boost::proto::detail::enable_binary<
133  vec_domain,
134  is_vec<int >,
135  int,
136  is_vec<vec<T,M> >,
137  vec<T,M>,
138  typename boost::proto::functional::make_expr<boost::proto::tag::plus, vec_domain>
139  ::impl<const int&, const vec<T,M>&>::result_type const
140 >::type
141 operator+ (const int& l, const vec<T,M>& r)
142 {
143  return boost::proto::functional::make_expr<boost::proto::tag::plus, vec_domain>
144  ::impl<const int&, const vec<T,M>&>() (l, r);
145 }
146 #else // BOOST_VERSION >= 104601
147 typename boost::proto::detail::enable_binary<
148  vec_domain,
149  vec_domain::proto_grammar,
150  boost::mpl::and_<
151  boost::mpl::or_<is_vec<int >, is_vec<vec<T,M> > >,
152  boost::mpl::not_<
153  boost::mpl::or_<
154  boost::proto::is_extension<int >,
155  boost::proto::is_extension<vec<T,M> >
156  >
157  >
158  >,
159  boost::proto::tag::plus,
160  int const &,
161  vec<T,M> const &
162 >::type /* const */
163 operator+ (int const &left, vec<T,M> const &right)
164 {
165  return boost::proto::detail::make_expr_<boost::proto::tag::plus, vec_domain, int const &, vec<T,M> const &>()(left, right);
166 }
167 #endif // BOOST_VERSION
168 template<class T, class M>
169 #if BOOST_VERSION < 104601
170 typename
171 boost::proto::detail::enable_binary<
172  vec_domain,
173  is_vec<T >,
174  T,
175  is_vec<vec<T,M> >,
176  vec<T,M>,
177  typename boost::proto::functional::make_expr<boost::proto::tag::plus, vec_domain>
178  ::impl<const T&, const vec<T,M>&>::result_type const
179 >::type
180 operator+ (const T& l, const vec<T,M>& r)
181 {
182  return boost::proto::functional::make_expr<boost::proto::tag::plus, vec_domain>
183  ::impl<const T&, const vec<T,M>&>() (l, r);
184 }
185 #else // BOOST_VERSION >= 104601
186 typename boost::proto::detail::enable_binary<
187  vec_domain,
188  vec_domain::proto_grammar,
189  boost::mpl::and_<
190  boost::mpl::or_<is_vec<T >, is_vec<vec<T,M> > >,
191  boost::mpl::not_<
192  boost::mpl::or_<
193  boost::proto::is_extension<T >,
194  boost::proto::is_extension<vec<T,M> >
195  >
196  >
197  >,
198  boost::proto::tag::plus,
199  T const &,
200  vec<T,M> const &
201 >::type /* const */
202 operator+ (T const &left, vec<T,M> const &right)
203 {
204  return boost::proto::detail::make_expr_<boost::proto::tag::plus, vec_domain, T const &, vec<T,M> const &>()(left, right);
205 }
206 #endif // BOOST_VERSION
207 template<class T, class M>
208 #if BOOST_VERSION < 104601
209 typename
210 boost::proto::detail::enable_binary<
211  vec_domain,
212  is_vec<vec<T,M> >,
213  vec<T,M>,
214  is_vec<int >,
215  int,
216  typename boost::proto::functional::make_expr<boost::proto::tag::plus, vec_domain>
217  ::impl<const vec<T,M>&, const int&>::result_type const
218 >::type
219 operator+ (const vec<T,M>& l, const int& r)
220 {
221  return boost::proto::functional::make_expr<boost::proto::tag::plus, vec_domain>
222  ::impl<const vec<T,M>&, const int&>() (l, r);
223 }
224 #else // BOOST_VERSION >= 104601
225 typename boost::proto::detail::enable_binary<
226  vec_domain,
227  vec_domain::proto_grammar,
228  boost::mpl::and_<
229  boost::mpl::or_<is_vec<vec<T,M> >, is_vec<int > >,
230  boost::mpl::not_<
231  boost::mpl::or_<
232  boost::proto::is_extension<vec<T,M> >,
233  boost::proto::is_extension<int >
234  >
235  >
236  >,
237  boost::proto::tag::plus,
238  vec<T,M> const &,
239  int const &
240 >::type /* const */
241 operator+ (vec<T,M> const &left, int const &right)
242 {
243  return boost::proto::detail::make_expr_<boost::proto::tag::plus, vec_domain, vec<T,M> const &, int const &>()(left, right);
244 }
245 #endif // BOOST_VERSION
246 template<class T, class M>
247 #if BOOST_VERSION < 104601
248 typename
249 boost::proto::detail::enable_binary<
250  vec_domain,
251  is_vec<vec<T,M> >,
252  vec<T,M>,
253  is_vec<T >,
254  T,
255  typename boost::proto::functional::make_expr<boost::proto::tag::plus, vec_domain>
256  ::impl<const vec<T,M>&, const T&>::result_type const
257 >::type
258 operator+ (const vec<T,M>& l, const T& r)
259 {
260  return boost::proto::functional::make_expr<boost::proto::tag::plus, vec_domain>
261  ::impl<const vec<T,M>&, const T&>() (l, r);
262 }
263 #else // BOOST_VERSION >= 104601
264 typename boost::proto::detail::enable_binary<
265  vec_domain,
266  vec_domain::proto_grammar,
267  boost::mpl::and_<
268  boost::mpl::or_<is_vec<vec<T,M> >, is_vec<T > >,
269  boost::mpl::not_<
270  boost::mpl::or_<
271  boost::proto::is_extension<vec<T,M> >,
272  boost::proto::is_extension<T >
273  >
274  >
275  >,
276  boost::proto::tag::plus,
277  vec<T,M> const &,
278  T const &
279 >::type /* const */
280 operator+ (vec<T,M> const &left, T const &right)
281 {
282  return boost::proto::detail::make_expr_<boost::proto::tag::plus, vec_domain, vec<T,M> const &, T const &>()(left, right);
283 }
284 #endif // BOOST_VERSION
285 template<class Expr>
286 #if BOOST_VERSION < 104601
287 typename
288 boost::proto::detail::enable_binary<
289  vec_domain,
290  is_vec<int >,
291  int,
292  is_vec<vec_expr<Expr> >,
293  vec_expr<Expr>,
294  typename boost::proto::functional::make_expr<boost::proto::tag::plus, vec_domain>
295  ::impl<const int&, const vec_expr<Expr>&>::result_type const
296 >::type
297 operator+ (const int& l, const vec_expr<Expr>& r)
298 {
299  return boost::proto::functional::make_expr<boost::proto::tag::plus, vec_domain>
300  ::impl<const int&, const vec_expr<Expr>&>() (l, r);
301 }
302 #else // BOOST_VERSION >= 104601
303 typename boost::proto::detail::enable_binary<
304  vec_domain,
305  vec_domain::proto_grammar,
306  boost::mpl::and_<
307  boost::mpl::or_<is_vec<int >, is_vec<vec_expr<Expr> > >,
308  boost::mpl::not_<
309  boost::mpl::or_<
310  boost::proto::is_extension<int >,
311  boost::proto::is_extension<vec_expr<Expr> >
312  >
313  >
314  >,
315  boost::proto::tag::plus,
316  int const &,
317  vec_expr<Expr> const &
318 >::type /* const */
319 operator+ (int const &left, vec_expr<Expr> const &right)
320 {
321  return boost::proto::detail::make_expr_<boost::proto::tag::plus, vec_domain, int const &, vec_expr<Expr> const &>()(left, right);
322 }
323 #endif // BOOST_VERSION
324 template<class Expr>
325 #if BOOST_VERSION < 104601
326 typename
327 boost::proto::detail::enable_binary<
328  vec_domain,
329  is_vec<vec_expr<Expr> >,
330  vec_expr<Expr>,
331  is_vec<int >,
332  int,
333  typename boost::proto::functional::make_expr<boost::proto::tag::plus, vec_domain>
334  ::impl<const vec_expr<Expr>&, const int&>::result_type const
335 >::type
336 operator+ (const vec_expr<Expr>& l, const int& r)
337 {
338  return boost::proto::functional::make_expr<boost::proto::tag::plus, vec_domain>
339  ::impl<const vec_expr<Expr>&, const int&>() (l, r);
340 }
341 #else // BOOST_VERSION >= 104601
342 typename boost::proto::detail::enable_binary<
343  vec_domain,
344  vec_domain::proto_grammar,
345  boost::mpl::and_<
346  boost::mpl::or_<is_vec<vec_expr<Expr> >, is_vec<int > >,
347  boost::mpl::not_<
348  boost::mpl::or_<
349  boost::proto::is_extension<vec_expr<Expr> >,
350  boost::proto::is_extension<int >
351  >
352  >
353  >,
354  boost::proto::tag::plus,
355  vec_expr<Expr> const &,
356  int const &
357 >::type /* const */
358 operator+ (vec_expr<Expr> const &left, int const &right)
359 {
360  return boost::proto::detail::make_expr_<boost::proto::tag::plus, vec_domain, vec_expr<Expr> const &, int const &>()(left, right);
361 }
362 #endif // BOOST_VERSION
363 template<class T, class Expr>
364 #if BOOST_VERSION < 104601
365 typename
366 boost::proto::detail::enable_binary<
367  vec_domain,
368  is_vec<T >,
369  T,
370  is_vec<vec_expr<Expr> >,
371  vec_expr<Expr>,
372  typename boost::proto::functional::make_expr<boost::proto::tag::plus, vec_domain>
373  ::impl<const T&, const vec_expr<Expr>&>::result_type const
374 >::type
375 operator+ (const T& l, const vec_expr<Expr>& r)
376 {
377  return boost::proto::functional::make_expr<boost::proto::tag::plus, vec_domain>
378  ::impl<const T&, const vec_expr<Expr>&>() (l, r);
379 }
380 #else // BOOST_VERSION >= 104601
381 typename boost::proto::detail::enable_binary<
382  vec_domain,
383  vec_domain::proto_grammar,
384  boost::mpl::and_<
385  boost::mpl::or_<is_vec<T >, is_vec<vec_expr<Expr> > >,
386  boost::mpl::not_<
387  boost::mpl::or_<
388  boost::proto::is_extension<T >,
389  boost::proto::is_extension<vec_expr<Expr> >
390  >
391  >
392  >,
393  boost::proto::tag::plus,
394  T const &,
395  vec_expr<Expr> const &
396 >::type /* const */
397 operator+ (T const &left, vec_expr<Expr> const &right)
398 {
399  return boost::proto::detail::make_expr_<boost::proto::tag::plus, vec_domain, T const &, vec_expr<Expr> const &>()(left, right);
400 }
401 #endif // BOOST_VERSION
402 template<class T, class Expr>
403 #if BOOST_VERSION < 104601
404 typename
405 boost::proto::detail::enable_binary<
406  vec_domain,
407  is_vec<vec_expr<Expr> >,
408  vec_expr<Expr>,
409  is_vec<T >,
410  T,
411  typename boost::proto::functional::make_expr<boost::proto::tag::plus, vec_domain>
412  ::impl<const vec_expr<Expr>&, const T&>::result_type const
413 >::type
414 operator+ (const vec_expr<Expr>& l, const T& r)
415 {
416  return boost::proto::functional::make_expr<boost::proto::tag::plus, vec_domain>
417  ::impl<const vec_expr<Expr>&, const T&>() (l, r);
418 }
419 #else // BOOST_VERSION >= 104601
420 typename boost::proto::detail::enable_binary<
421  vec_domain,
422  vec_domain::proto_grammar,
423  boost::mpl::and_<
424  boost::mpl::or_<is_vec<vec_expr<Expr> >, is_vec<T > >,
425  boost::mpl::not_<
426  boost::mpl::or_<
427  boost::proto::is_extension<vec_expr<Expr> >,
428  boost::proto::is_extension<T >
429  >
430  >
431  >,
432  boost::proto::tag::plus,
433  vec_expr<Expr> const &,
434  T const &
435 >::type /* const */
436 operator+ (vec_expr<Expr> const &left, T const &right)
437 {
438  return boost::proto::detail::make_expr_<boost::proto::tag::plus, vec_domain, vec_expr<Expr> const &, T const &>()(left, right);
439 }
440 #endif // BOOST_VERSION
441 template<class T1, class T2, class M>
442 #if BOOST_VERSION < 104601
443 typename
444 boost::proto::detail::enable_binary<
445  vec_domain,
446  is_vec<vec<T1,M> >,
447  vec<T1,M>,
448  is_vec<vec<T2,M> >,
449  vec<T2,M>,
450  typename boost::proto::functional::make_expr<boost::proto::tag::plus, vec_domain>
451  ::impl<const vec<T1,M>&, const vec<T2,M>&>::result_type const
452 >::type
453 operator+ (const vec<T1,M>& l, const vec<T2,M>& r)
454 {
455  return boost::proto::functional::make_expr<boost::proto::tag::plus, vec_domain>
456  ::impl<const vec<T1,M>&, const vec<T2,M>&>() (l, r);
457 }
458 #else // BOOST_VERSION >= 104601
459 typename boost::proto::detail::enable_binary<
460  vec_domain,
461  vec_domain::proto_grammar,
462  boost::mpl::and_<
463  boost::mpl::or_<is_vec<vec<T1,M> >, is_vec<vec<T2,M> > >,
464  boost::mpl::not_<
465  boost::mpl::or_<
466  boost::proto::is_extension<vec<T1,M> >,
467  boost::proto::is_extension<vec<T2,M> >
468  >
469  >
470  >,
471  boost::proto::tag::plus,
472  vec<T1,M> const &,
473  vec<T2,M> const &
474 >::type /* const */
475 operator+ (vec<T1,M> const &left, vec<T2,M> const &right)
476 {
477  return boost::proto::detail::make_expr_<boost::proto::tag::plus, vec_domain, vec<T1,M> const &, vec<T2,M> const &>()(left, right);
478 }
479 #endif // BOOST_VERSION
480 template<class T, class M, class Expr>
481 #if BOOST_VERSION < 104601
482 typename
483 boost::proto::detail::enable_binary<
484  vec_domain,
485  is_vec<vec<T,M> >,
486  vec<T,M>,
487  is_vec<vec_expr<Expr> >,
488  vec_expr<Expr>,
489  typename boost::proto::functional::make_expr<boost::proto::tag::plus, vec_domain>
490  ::impl<const vec<T,M>&, const vec_expr<Expr>&>::result_type const
491 >::type
492 operator+ (const vec<T,M>& l, const vec_expr<Expr>& r)
493 {
494  return boost::proto::functional::make_expr<boost::proto::tag::plus, vec_domain>
495  ::impl<const vec<T,M>&, const vec_expr<Expr>&>() (l, r);
496 }
497 #else // BOOST_VERSION >= 104601
498 typename boost::proto::detail::enable_binary<
499  vec_domain,
500  vec_domain::proto_grammar,
501  boost::mpl::and_<
502  boost::mpl::or_<is_vec<vec<T,M> >, is_vec<vec_expr<Expr> > >,
503  boost::mpl::not_<
504  boost::mpl::or_<
505  boost::proto::is_extension<vec<T,M> >,
506  boost::proto::is_extension<vec_expr<Expr> >
507  >
508  >
509  >,
510  boost::proto::tag::plus,
511  vec<T,M> const &,
512  vec_expr<Expr> const &
513 >::type /* const */
514 operator+ (vec<T,M> const &left, vec_expr<Expr> const &right)
515 {
516  return boost::proto::detail::make_expr_<boost::proto::tag::plus, vec_domain, vec<T,M> const &, vec_expr<Expr> const &>()(left, right);
517 }
518 #endif // BOOST_VERSION
519 template<class T, class M, class Expr>
520 #if BOOST_VERSION < 104601
521 typename
522 boost::proto::detail::enable_binary<
523  vec_domain,
524  is_vec<vec_expr<Expr> >,
525  vec_expr<Expr>,
526  is_vec<vec<T,M> >,
527  vec<T,M>,
528  typename boost::proto::functional::make_expr<boost::proto::tag::plus, vec_domain>
529  ::impl<const vec_expr<Expr>&, const vec<T,M>&>::result_type const
530 >::type
531 operator+ (const vec_expr<Expr>& l, const vec<T,M>& r)
532 {
533  return boost::proto::functional::make_expr<boost::proto::tag::plus, vec_domain>
534  ::impl<const vec_expr<Expr>&, const vec<T,M>&>() (l, r);
535 }
536 #else // BOOST_VERSION >= 104601
537 typename boost::proto::detail::enable_binary<
538  vec_domain,
539  vec_domain::proto_grammar,
540  boost::mpl::and_<
541  boost::mpl::or_<is_vec<vec_expr<Expr> >, is_vec<vec<T,M> > >,
542  boost::mpl::not_<
543  boost::mpl::or_<
544  boost::proto::is_extension<vec_expr<Expr> >,
545  boost::proto::is_extension<vec<T,M> >
546  >
547  >
548  >,
549  boost::proto::tag::plus,
550  vec_expr<Expr> const &,
551  vec<T,M> const &
552 >::type /* const */
553 operator+ (vec_expr<Expr> const &left, vec<T,M> const &right)
554 {
555  return boost::proto::detail::make_expr_<boost::proto::tag::plus, vec_domain, vec_expr<Expr> const &, vec<T,M> const &>()(left, right);
556 }
557 #endif // BOOST_VERSION
558 template<class Expr1, class Expr2>
559 #if BOOST_VERSION < 104601
560 typename
561 boost::proto::detail::enable_binary<
562  vec_domain,
563  is_vec<vec_expr<Expr1> >,
564  vec_expr<Expr1>,
565  is_vec<vec_expr<Expr2> >,
566  vec_expr<Expr2>,
567  typename boost::proto::functional::make_expr<boost::proto::tag::plus, vec_domain>
568  ::impl<const vec_expr<Expr1>&, const vec_expr<Expr2>&>::result_type const
569 >::type
571 {
572  return boost::proto::functional::make_expr<boost::proto::tag::plus, vec_domain>
573  ::impl<const vec_expr<Expr1>&, const vec_expr<Expr2>&>() (l, r);
574 }
575 #else // BOOST_VERSION >= 104601
576 typename boost::proto::detail::enable_binary<
577  vec_domain,
578  vec_domain::proto_grammar,
579  boost::mpl::and_<
580  boost::mpl::or_<is_vec<vec_expr<Expr1> >, is_vec<vec_expr<Expr2> > >,
581  boost::mpl::not_<
582  boost::mpl::or_<
583  boost::proto::is_extension<vec_expr<Expr1> >,
584  boost::proto::is_extension<vec_expr<Expr2> >
585  >
586  >
587  >,
588  boost::proto::tag::plus,
589  vec_expr<Expr1> const &,
590  vec_expr<Expr2> const &
591 >::type /* const */
592 operator+ (vec_expr<Expr1> const &left, vec_expr<Expr2> const &right)
593 {
594  return boost::proto::detail::make_expr_<boost::proto::tag::plus, vec_domain, vec_expr<Expr1> const &, vec_expr<Expr2> const &>()(left, right);
595 }
596 #endif // BOOST_VERSION
597 template<class T, class M>
598 #if BOOST_VERSION < 104601
599 typename
600 boost::proto::detail::enable_binary<
601  vec_domain,
602  is_vec<int >,
603  int,
604  is_vec<vec<T,M> >,
605  vec<T,M>,
606  typename boost::proto::functional::make_expr<boost::proto::tag::minus, vec_domain>
607  ::impl<const int&, const vec<T,M>&>::result_type const
608 >::type
609 operator- (const int& l, const vec<T,M>& r)
610 {
611  return boost::proto::functional::make_expr<boost::proto::tag::minus, vec_domain>
612  ::impl<const int&, const vec<T,M>&>() (l, r);
613 }
614 #else // BOOST_VERSION >= 104601
615 typename boost::proto::detail::enable_binary<
616  vec_domain,
617  vec_domain::proto_grammar,
618  boost::mpl::and_<
619  boost::mpl::or_<is_vec<int >, is_vec<vec<T,M> > >,
620  boost::mpl::not_<
621  boost::mpl::or_<
622  boost::proto::is_extension<int >,
623  boost::proto::is_extension<vec<T,M> >
624  >
625  >
626  >,
627  boost::proto::tag::minus,
628  int const &,
629  vec<T,M> const &
630 >::type /* const */
631 operator- (int const &left, vec<T,M> const &right)
632 {
633  return boost::proto::detail::make_expr_<boost::proto::tag::minus, vec_domain, int const &, vec<T,M> const &>()(left, right);
634 }
635 #endif // BOOST_VERSION
636 template<class T, class M>
637 #if BOOST_VERSION < 104601
638 typename
639 boost::proto::detail::enable_binary<
640  vec_domain,
641  is_vec<T >,
642  T,
643  is_vec<vec<T,M> >,
644  vec<T,M>,
645  typename boost::proto::functional::make_expr<boost::proto::tag::minus, vec_domain>
646  ::impl<const T&, const vec<T,M>&>::result_type const
647 >::type
648 operator- (const T& l, const vec<T,M>& r)
649 {
650  return boost::proto::functional::make_expr<boost::proto::tag::minus, vec_domain>
651  ::impl<const T&, const vec<T,M>&>() (l, r);
652 }
653 #else // BOOST_VERSION >= 104601
654 typename boost::proto::detail::enable_binary<
655  vec_domain,
656  vec_domain::proto_grammar,
657  boost::mpl::and_<
658  boost::mpl::or_<is_vec<T >, is_vec<vec<T,M> > >,
659  boost::mpl::not_<
660  boost::mpl::or_<
661  boost::proto::is_extension<T >,
662  boost::proto::is_extension<vec<T,M> >
663  >
664  >
665  >,
666  boost::proto::tag::minus,
667  T const &,
668  vec<T,M> const &
669 >::type /* const */
670 operator- (T const &left, vec<T,M> const &right)
671 {
672  return boost::proto::detail::make_expr_<boost::proto::tag::minus, vec_domain, T const &, vec<T,M> const &>()(left, right);
673 }
674 #endif // BOOST_VERSION
675 template<class T, class M>
676 #if BOOST_VERSION < 104601
677 typename
678 boost::proto::detail::enable_binary<
679  vec_domain,
680  is_vec<vec<T,M> >,
681  vec<T,M>,
682  is_vec<int >,
683  int,
684  typename boost::proto::functional::make_expr<boost::proto::tag::minus, vec_domain>
685  ::impl<const vec<T,M>&, const int&>::result_type const
686 >::type
687 operator- (const vec<T,M>& l, const int& r)
688 {
689  return boost::proto::functional::make_expr<boost::proto::tag::minus, vec_domain>
690  ::impl<const vec<T,M>&, const int&>() (l, r);
691 }
692 #else // BOOST_VERSION >= 104601
693 typename boost::proto::detail::enable_binary<
694  vec_domain,
695  vec_domain::proto_grammar,
696  boost::mpl::and_<
697  boost::mpl::or_<is_vec<vec<T,M> >, is_vec<int > >,
698  boost::mpl::not_<
699  boost::mpl::or_<
700  boost::proto::is_extension<vec<T,M> >,
701  boost::proto::is_extension<int >
702  >
703  >
704  >,
705  boost::proto::tag::minus,
706  vec<T,M> const &,
707  int const &
708 >::type /* const */
709 operator- (vec<T,M> const &left, int const &right)
710 {
711  return boost::proto::detail::make_expr_<boost::proto::tag::minus, vec_domain, vec<T,M> const &, int const &>()(left, right);
712 }
713 #endif // BOOST_VERSION
714 template<class T, class M>
715 #if BOOST_VERSION < 104601
716 typename
717 boost::proto::detail::enable_binary<
718  vec_domain,
719  is_vec<vec<T,M> >,
720  vec<T,M>,
721  is_vec<T >,
722  T,
723  typename boost::proto::functional::make_expr<boost::proto::tag::minus, vec_domain>
724  ::impl<const vec<T,M>&, const T&>::result_type const
725 >::type
726 operator- (const vec<T,M>& l, const T& r)
727 {
728  return boost::proto::functional::make_expr<boost::proto::tag::minus, vec_domain>
729  ::impl<const vec<T,M>&, const T&>() (l, r);
730 }
731 #else // BOOST_VERSION >= 104601
732 typename boost::proto::detail::enable_binary<
733  vec_domain,
734  vec_domain::proto_grammar,
735  boost::mpl::and_<
736  boost::mpl::or_<is_vec<vec<T,M> >, is_vec<T > >,
737  boost::mpl::not_<
738  boost::mpl::or_<
739  boost::proto::is_extension<vec<T,M> >,
740  boost::proto::is_extension<T >
741  >
742  >
743  >,
744  boost::proto::tag::minus,
745  vec<T,M> const &,
746  T const &
747 >::type /* const */
748 operator- (vec<T,M> const &left, T const &right)
749 {
750  return boost::proto::detail::make_expr_<boost::proto::tag::minus, vec_domain, vec<T,M> const &, T const &>()(left, right);
751 }
752 #endif // BOOST_VERSION
753 template<class Expr>
754 #if BOOST_VERSION < 104601
755 typename
756 boost::proto::detail::enable_binary<
757  vec_domain,
758  is_vec<int >,
759  int,
760  is_vec<vec_expr<Expr> >,
761  vec_expr<Expr>,
762  typename boost::proto::functional::make_expr<boost::proto::tag::minus, vec_domain>
763  ::impl<const int&, const vec_expr<Expr>&>::result_type const
764 >::type
765 operator- (const int& l, const vec_expr<Expr>& r)
766 {
767  return boost::proto::functional::make_expr<boost::proto::tag::minus, vec_domain>
768  ::impl<const int&, const vec_expr<Expr>&>() (l, r);
769 }
770 #else // BOOST_VERSION >= 104601
771 typename boost::proto::detail::enable_binary<
772  vec_domain,
773  vec_domain::proto_grammar,
774  boost::mpl::and_<
775  boost::mpl::or_<is_vec<int >, is_vec<vec_expr<Expr> > >,
776  boost::mpl::not_<
777  boost::mpl::or_<
778  boost::proto::is_extension<int >,
779  boost::proto::is_extension<vec_expr<Expr> >
780  >
781  >
782  >,
783  boost::proto::tag::minus,
784  int const &,
785  vec_expr<Expr> const &
786 >::type /* const */
787 operator- (int const &left, vec_expr<Expr> const &right)
788 {
789  return boost::proto::detail::make_expr_<boost::proto::tag::minus, vec_domain, int const &, vec_expr<Expr> const &>()(left, right);
790 }
791 #endif // BOOST_VERSION
792 template<class Expr>
793 #if BOOST_VERSION < 104601
794 typename
795 boost::proto::detail::enable_binary<
796  vec_domain,
797  is_vec<vec_expr<Expr> >,
798  vec_expr<Expr>,
799  is_vec<int >,
800  int,
801  typename boost::proto::functional::make_expr<boost::proto::tag::minus, vec_domain>
802  ::impl<const vec_expr<Expr>&, const int&>::result_type const
803 >::type
804 operator- (const vec_expr<Expr>& l, const int& r)
805 {
806  return boost::proto::functional::make_expr<boost::proto::tag::minus, vec_domain>
807  ::impl<const vec_expr<Expr>&, const int&>() (l, r);
808 }
809 #else // BOOST_VERSION >= 104601
810 typename boost::proto::detail::enable_binary<
811  vec_domain,
812  vec_domain::proto_grammar,
813  boost::mpl::and_<
814  boost::mpl::or_<is_vec<vec_expr<Expr> >, is_vec<int > >,
815  boost::mpl::not_<
816  boost::mpl::or_<
817  boost::proto::is_extension<vec_expr<Expr> >,
818  boost::proto::is_extension<int >
819  >
820  >
821  >,
822  boost::proto::tag::minus,
823  vec_expr<Expr> const &,
824  int const &
825 >::type /* const */
826 operator- (vec_expr<Expr> const &left, int const &right)
827 {
828  return boost::proto::detail::make_expr_<boost::proto::tag::minus, vec_domain, vec_expr<Expr> const &, int const &>()(left, right);
829 }
830 #endif // BOOST_VERSION
831 template<class T, class Expr>
832 #if BOOST_VERSION < 104601
833 typename
834 boost::proto::detail::enable_binary<
835  vec_domain,
836  is_vec<T >,
837  T,
838  is_vec<vec_expr<Expr> >,
839  vec_expr<Expr>,
840  typename boost::proto::functional::make_expr<boost::proto::tag::minus, vec_domain>
841  ::impl<const T&, const vec_expr<Expr>&>::result_type const
842 >::type
843 operator- (const T& l, const vec_expr<Expr>& r)
844 {
845  return boost::proto::functional::make_expr<boost::proto::tag::minus, vec_domain>
846  ::impl<const T&, const vec_expr<Expr>&>() (l, r);
847 }
848 #else // BOOST_VERSION >= 104601
849 typename boost::proto::detail::enable_binary<
850  vec_domain,
851  vec_domain::proto_grammar,
852  boost::mpl::and_<
853  boost::mpl::or_<is_vec<T >, is_vec<vec_expr<Expr> > >,
854  boost::mpl::not_<
855  boost::mpl::or_<
856  boost::proto::is_extension<T >,
857  boost::proto::is_extension<vec_expr<Expr> >
858  >
859  >
860  >,
861  boost::proto::tag::minus,
862  T const &,
863  vec_expr<Expr> const &
864 >::type /* const */
865 operator- (T const &left, vec_expr<Expr> const &right)
866 {
867  return boost::proto::detail::make_expr_<boost::proto::tag::minus, vec_domain, T const &, vec_expr<Expr> const &>()(left, right);
868 }
869 #endif // BOOST_VERSION
870 template<class T, class Expr>
871 #if BOOST_VERSION < 104601
872 typename
873 boost::proto::detail::enable_binary<
874  vec_domain,
875  is_vec<vec_expr<Expr> >,
876  vec_expr<Expr>,
877  is_vec<T >,
878  T,
879  typename boost::proto::functional::make_expr<boost::proto::tag::minus, vec_domain>
880  ::impl<const vec_expr<Expr>&, const T&>::result_type const
881 >::type
882 operator- (const vec_expr<Expr>& l, const T& r)
883 {
884  return boost::proto::functional::make_expr<boost::proto::tag::minus, vec_domain>
885  ::impl<const vec_expr<Expr>&, const T&>() (l, r);
886 }
887 #else // BOOST_VERSION >= 104601
888 typename boost::proto::detail::enable_binary<
889  vec_domain,
890  vec_domain::proto_grammar,
891  boost::mpl::and_<
892  boost::mpl::or_<is_vec<vec_expr<Expr> >, is_vec<T > >,
893  boost::mpl::not_<
894  boost::mpl::or_<
895  boost::proto::is_extension<vec_expr<Expr> >,
896  boost::proto::is_extension<T >
897  >
898  >
899  >,
900  boost::proto::tag::minus,
901  vec_expr<Expr> const &,
902  T const &
903 >::type /* const */
904 operator- (vec_expr<Expr> const &left, T const &right)
905 {
906  return boost::proto::detail::make_expr_<boost::proto::tag::minus, vec_domain, vec_expr<Expr> const &, T const &>()(left, right);
907 }
908 #endif // BOOST_VERSION
909 template<class T1, class T2, class M>
910 #if BOOST_VERSION < 104601
911 typename
912 boost::proto::detail::enable_binary<
913  vec_domain,
914  is_vec<vec<T1,M> >,
915  vec<T1,M>,
916  is_vec<vec<T2,M> >,
917  vec<T2,M>,
918  typename boost::proto::functional::make_expr<boost::proto::tag::minus, vec_domain>
919  ::impl<const vec<T1,M>&, const vec<T2,M>&>::result_type const
920 >::type
921 operator- (const vec<T1,M>& l, const vec<T2,M>& r)
922 {
923  return boost::proto::functional::make_expr<boost::proto::tag::minus, vec_domain>
924  ::impl<const vec<T1,M>&, const vec<T2,M>&>() (l, r);
925 }
926 #else // BOOST_VERSION >= 104601
927 typename boost::proto::detail::enable_binary<
928  vec_domain,
929  vec_domain::proto_grammar,
930  boost::mpl::and_<
931  boost::mpl::or_<is_vec<vec<T1,M> >, is_vec<vec<T2,M> > >,
932  boost::mpl::not_<
933  boost::mpl::or_<
934  boost::proto::is_extension<vec<T1,M> >,
935  boost::proto::is_extension<vec<T2,M> >
936  >
937  >
938  >,
939  boost::proto::tag::minus,
940  vec<T1,M> const &,
941  vec<T2,M> const &
942 >::type /* const */
943 operator- (vec<T1,M> const &left, vec<T2,M> const &right)
944 {
945  return boost::proto::detail::make_expr_<boost::proto::tag::minus, vec_domain, vec<T1,M> const &, vec<T2,M> const &>()(left, right);
946 }
947 #endif // BOOST_VERSION
948 template<class T, class M, class Expr>
949 #if BOOST_VERSION < 104601
950 typename
951 boost::proto::detail::enable_binary<
952  vec_domain,
953  is_vec<vec<T,M> >,
954  vec<T,M>,
955  is_vec<vec_expr<Expr> >,
956  vec_expr<Expr>,
957  typename boost::proto::functional::make_expr<boost::proto::tag::minus, vec_domain>
958  ::impl<const vec<T,M>&, const vec_expr<Expr>&>::result_type const
959 >::type
960 operator- (const vec<T,M>& l, const vec_expr<Expr>& r)
961 {
962  return boost::proto::functional::make_expr<boost::proto::tag::minus, vec_domain>
963  ::impl<const vec<T,M>&, const vec_expr<Expr>&>() (l, r);
964 }
965 #else // BOOST_VERSION >= 104601
966 typename boost::proto::detail::enable_binary<
967  vec_domain,
968  vec_domain::proto_grammar,
969  boost::mpl::and_<
970  boost::mpl::or_<is_vec<vec<T,M> >, is_vec<vec_expr<Expr> > >,
971  boost::mpl::not_<
972  boost::mpl::or_<
973  boost::proto::is_extension<vec<T,M> >,
974  boost::proto::is_extension<vec_expr<Expr> >
975  >
976  >
977  >,
978  boost::proto::tag::minus,
979  vec<T,M> const &,
980  vec_expr<Expr> const &
981 >::type /* const */
982 operator- (vec<T,M> const &left, vec_expr<Expr> const &right)
983 {
984  return boost::proto::detail::make_expr_<boost::proto::tag::minus, vec_domain, vec<T,M> const &, vec_expr<Expr> const &>()(left, right);
985 }
986 #endif // BOOST_VERSION
987 template<class T, class M, class Expr>
988 #if BOOST_VERSION < 104601
989 typename
990 boost::proto::detail::enable_binary<
991  vec_domain,
992  is_vec<vec_expr<Expr> >,
993  vec_expr<Expr>,
994  is_vec<vec<T,M> >,
995  vec<T,M>,
996  typename boost::proto::functional::make_expr<boost::proto::tag::minus, vec_domain>
997  ::impl<const vec_expr<Expr>&, const vec<T,M>&>::result_type const
998 >::type
999 operator- (const vec_expr<Expr>& l, const vec<T,M>& r)
1000 {
1001  return boost::proto::functional::make_expr<boost::proto::tag::minus, vec_domain>
1002  ::impl<const vec_expr<Expr>&, const vec<T,M>&>() (l, r);
1003 }
1004 #else // BOOST_VERSION >= 104601
1005 typename boost::proto::detail::enable_binary<
1006  vec_domain,
1007  vec_domain::proto_grammar,
1008  boost::mpl::and_<
1009  boost::mpl::or_<is_vec<vec_expr<Expr> >, is_vec<vec<T,M> > >,
1010  boost::mpl::not_<
1011  boost::mpl::or_<
1012  boost::proto::is_extension<vec_expr<Expr> >,
1013  boost::proto::is_extension<vec<T,M> >
1014  >
1015  >
1016  >,
1017  boost::proto::tag::minus,
1018  vec_expr<Expr> const &,
1019  vec<T,M> const &
1020 >::type /* const */
1021 operator- (vec_expr<Expr> const &left, vec<T,M> const &right)
1022 {
1023  return boost::proto::detail::make_expr_<boost::proto::tag::minus, vec_domain, vec_expr<Expr> const &, vec<T,M> const &>()(left, right);
1024 }
1025 #endif // BOOST_VERSION
1026 template<class Expr1, class Expr2>
1027 #if BOOST_VERSION < 104601
1028 typename
1029 boost::proto::detail::enable_binary<
1030  vec_domain,
1031  is_vec<vec_expr<Expr1> >,
1032  vec_expr<Expr1>,
1033  is_vec<vec_expr<Expr2> >,
1034  vec_expr<Expr2>,
1035  typename boost::proto::functional::make_expr<boost::proto::tag::minus, vec_domain>
1036  ::impl<const vec_expr<Expr1>&, const vec_expr<Expr2>&>::result_type const
1037 >::type
1039 {
1040  return boost::proto::functional::make_expr<boost::proto::tag::minus, vec_domain>
1041  ::impl<const vec_expr<Expr1>&, const vec_expr<Expr2>&>() (l, r);
1042 }
1043 #else // BOOST_VERSION >= 104601
1044 typename boost::proto::detail::enable_binary<
1045  vec_domain,
1046  vec_domain::proto_grammar,
1047  boost::mpl::and_<
1048  boost::mpl::or_<is_vec<vec_expr<Expr1> >, is_vec<vec_expr<Expr2> > >,
1049  boost::mpl::not_<
1050  boost::mpl::or_<
1051  boost::proto::is_extension<vec_expr<Expr1> >,
1052  boost::proto::is_extension<vec_expr<Expr2> >
1053  >
1054  >
1055  >,
1056  boost::proto::tag::minus,
1057  vec_expr<Expr1> const &,
1058  vec_expr<Expr2> const &
1059 >::type /* const */
1060 operator- (vec_expr<Expr1> const &left, vec_expr<Expr2> const &right)
1061 {
1062  return boost::proto::detail::make_expr_<boost::proto::tag::minus, vec_domain, vec_expr<Expr1> const &, vec_expr<Expr2> const &>()(left, right);
1063 }
1064 #endif // BOOST_VERSION
1065 template<class T, class M>
1066 #if BOOST_VERSION < 104601
1067 typename
1068 boost::proto::detail::enable_binary<
1069  vec_domain,
1070  is_vec<int >,
1071  int,
1072  is_vec<vec<T,M> >,
1073  vec<T,M>,
1074  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, vec_domain>
1075  ::impl<const int&, const vec<T,M>&>::result_type const
1076 >::type
1077 operator* (const int& l, const vec<T,M>& r)
1078 {
1079  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, vec_domain>
1080  ::impl<const int&, const vec<T,M>&>() (l, r);
1081 }
1082 #else // BOOST_VERSION >= 104601
1083 typename boost::proto::detail::enable_binary<
1084  vec_domain,
1085  vec_domain::proto_grammar,
1086  boost::mpl::and_<
1087  boost::mpl::or_<is_vec<int >, is_vec<vec<T,M> > >,
1088  boost::mpl::not_<
1089  boost::mpl::or_<
1090  boost::proto::is_extension<int >,
1091  boost::proto::is_extension<vec<T,M> >
1092  >
1093  >
1094  >,
1095  boost::proto::tag::multiplies,
1096  int const &,
1097  vec<T,M> const &
1098 >::type /* const */
1099 operator* (int const &left, vec<T,M> const &right)
1100 {
1101  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, vec_domain, int const &, vec<T,M> const &>()(left, right);
1102 }
1103 #endif // BOOST_VERSION
1104 template<class T, class M>
1105 #if BOOST_VERSION < 104601
1106 typename
1107 boost::proto::detail::enable_binary<
1108  vec_domain,
1109  is_vec<T >,
1110  T,
1111  is_vec<vec<T,M> >,
1112  vec<T,M>,
1113  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, vec_domain>
1114  ::impl<const T&, const vec<T,M>&>::result_type const
1115 >::type
1116 operator* (const T& l, const vec<T,M>& r)
1117 {
1118  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, vec_domain>
1119  ::impl<const T&, const vec<T,M>&>() (l, r);
1120 }
1121 #else // BOOST_VERSION >= 104601
1122 typename boost::proto::detail::enable_binary<
1123  vec_domain,
1124  vec_domain::proto_grammar,
1125  boost::mpl::and_<
1126  boost::mpl::or_<is_vec<T >, is_vec<vec<T,M> > >,
1127  boost::mpl::not_<
1128  boost::mpl::or_<
1129  boost::proto::is_extension<T >,
1130  boost::proto::is_extension<vec<T,M> >
1131  >
1132  >
1133  >,
1134  boost::proto::tag::multiplies,
1135  T const &,
1136  vec<T,M> const &
1137 >::type /* const */
1138 operator* (T const &left, vec<T,M> const &right)
1139 {
1140  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, vec_domain, T const &, vec<T,M> const &>()(left, right);
1141 }
1142 #endif // BOOST_VERSION
1143 template<class T, class M>
1144 #if BOOST_VERSION < 104601
1145 typename
1146 boost::proto::detail::enable_binary<
1147  vec_domain,
1148  is_vec<vec<T,M> >,
1149  vec<T,M>,
1150  is_vec<int >,
1151  int,
1152  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, vec_domain>
1153  ::impl<const vec<T,M>&, const int&>::result_type const
1154 >::type
1155 operator* (const vec<T,M>& l, const int& r)
1156 {
1157  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, vec_domain>
1158  ::impl<const vec<T,M>&, const int&>() (l, r);
1159 }
1160 #else // BOOST_VERSION >= 104601
1161 typename boost::proto::detail::enable_binary<
1162  vec_domain,
1163  vec_domain::proto_grammar,
1164  boost::mpl::and_<
1165  boost::mpl::or_<is_vec<vec<T,M> >, is_vec<int > >,
1166  boost::mpl::not_<
1167  boost::mpl::or_<
1168  boost::proto::is_extension<vec<T,M> >,
1169  boost::proto::is_extension<int >
1170  >
1171  >
1172  >,
1173  boost::proto::tag::multiplies,
1174  vec<T,M> const &,
1175  int const &
1176 >::type /* const */
1177 operator* (vec<T,M> const &left, int const &right)
1178 {
1179  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, vec_domain, vec<T,M> const &, int const &>()(left, right);
1180 }
1181 #endif // BOOST_VERSION
1182 template<class T, class M>
1183 #if BOOST_VERSION < 104601
1184 typename
1185 boost::proto::detail::enable_binary<
1186  vec_domain,
1187  is_vec<vec<T,M> >,
1188  vec<T,M>,
1189  is_vec<T >,
1190  T,
1191  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, vec_domain>
1192  ::impl<const vec<T,M>&, const T&>::result_type const
1193 >::type
1194 operator* (const vec<T,M>& l, const T& r)
1195 {
1196  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, vec_domain>
1197  ::impl<const vec<T,M>&, const T&>() (l, r);
1198 }
1199 #else // BOOST_VERSION >= 104601
1200 typename boost::proto::detail::enable_binary<
1201  vec_domain,
1202  vec_domain::proto_grammar,
1203  boost::mpl::and_<
1204  boost::mpl::or_<is_vec<vec<T,M> >, is_vec<T > >,
1205  boost::mpl::not_<
1206  boost::mpl::or_<
1207  boost::proto::is_extension<vec<T,M> >,
1208  boost::proto::is_extension<T >
1209  >
1210  >
1211  >,
1212  boost::proto::tag::multiplies,
1213  vec<T,M> const &,
1214  T const &
1215 >::type /* const */
1216 operator* (vec<T,M> const &left, T const &right)
1217 {
1218  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, vec_domain, vec<T,M> const &, T const &>()(left, right);
1219 }
1220 #endif // BOOST_VERSION
1221 template<class Expr>
1222 #if BOOST_VERSION < 104601
1223 typename
1224 boost::proto::detail::enable_binary<
1225  vec_domain,
1226  is_vec<int >,
1227  int,
1228  is_vec<vec_expr<Expr> >,
1229  vec_expr<Expr>,
1230  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, vec_domain>
1231  ::impl<const int&, const vec_expr<Expr>&>::result_type const
1232 >::type
1233 operator* (const int& l, const vec_expr<Expr>& r)
1234 {
1235  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, vec_domain>
1236  ::impl<const int&, const vec_expr<Expr>&>() (l, r);
1237 }
1238 #else // BOOST_VERSION >= 104601
1239 typename boost::proto::detail::enable_binary<
1240  vec_domain,
1241  vec_domain::proto_grammar,
1242  boost::mpl::and_<
1243  boost::mpl::or_<is_vec<int >, is_vec<vec_expr<Expr> > >,
1244  boost::mpl::not_<
1245  boost::mpl::or_<
1246  boost::proto::is_extension<int >,
1247  boost::proto::is_extension<vec_expr<Expr> >
1248  >
1249  >
1250  >,
1251  boost::proto::tag::multiplies,
1252  int const &,
1253  vec_expr<Expr> const &
1254 >::type /* const */
1255 operator* (int const &left, vec_expr<Expr> const &right)
1256 {
1257  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, vec_domain, int const &, vec_expr<Expr> const &>()(left, right);
1258 }
1259 #endif // BOOST_VERSION
1260 template<class Expr>
1261 #if BOOST_VERSION < 104601
1262 typename
1263 boost::proto::detail::enable_binary<
1264  vec_domain,
1265  is_vec<vec_expr<Expr> >,
1266  vec_expr<Expr>,
1267  is_vec<int >,
1268  int,
1269  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, vec_domain>
1270  ::impl<const vec_expr<Expr>&, const int&>::result_type const
1271 >::type
1272 operator* (const vec_expr<Expr>& l, const int& r)
1273 {
1274  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, vec_domain>
1275  ::impl<const vec_expr<Expr>&, const int&>() (l, r);
1276 }
1277 #else // BOOST_VERSION >= 104601
1278 typename boost::proto::detail::enable_binary<
1279  vec_domain,
1280  vec_domain::proto_grammar,
1281  boost::mpl::and_<
1282  boost::mpl::or_<is_vec<vec_expr<Expr> >, is_vec<int > >,
1283  boost::mpl::not_<
1284  boost::mpl::or_<
1285  boost::proto::is_extension<vec_expr<Expr> >,
1286  boost::proto::is_extension<int >
1287  >
1288  >
1289  >,
1290  boost::proto::tag::multiplies,
1291  vec_expr<Expr> const &,
1292  int const &
1293 >::type /* const */
1294 operator* (vec_expr<Expr> const &left, int const &right)
1295 {
1296  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, vec_domain, vec_expr<Expr> const &, int const &>()(left, right);
1297 }
1298 #endif // BOOST_VERSION
1299 template<class T, class Expr>
1300 #if BOOST_VERSION < 104601
1301 typename
1302 boost::proto::detail::enable_binary<
1303  vec_domain,
1304  is_vec<T >,
1305  T,
1306  is_vec<vec_expr<Expr> >,
1307  vec_expr<Expr>,
1308  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, vec_domain>
1309  ::impl<const T&, const vec_expr<Expr>&>::result_type const
1310 >::type
1311 operator* (const T& l, const vec_expr<Expr>& r)
1312 {
1313  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, vec_domain>
1314  ::impl<const T&, const vec_expr<Expr>&>() (l, r);
1315 }
1316 #else // BOOST_VERSION >= 104601
1317 typename boost::proto::detail::enable_binary<
1318  vec_domain,
1319  vec_domain::proto_grammar,
1320  boost::mpl::and_<
1321  boost::mpl::or_<is_vec<T >, is_vec<vec_expr<Expr> > >,
1322  boost::mpl::not_<
1323  boost::mpl::or_<
1324  boost::proto::is_extension<T >,
1325  boost::proto::is_extension<vec_expr<Expr> >
1326  >
1327  >
1328  >,
1329  boost::proto::tag::multiplies,
1330  T const &,
1331  vec_expr<Expr> const &
1332 >::type /* const */
1333 operator* (T const &left, vec_expr<Expr> const &right)
1334 {
1335  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, vec_domain, T const &, vec_expr<Expr> const &>()(left, right);
1336 }
1337 #endif // BOOST_VERSION
1338 template<class T, class Expr>
1339 #if BOOST_VERSION < 104601
1340 typename
1341 boost::proto::detail::enable_binary<
1342  vec_domain,
1343  is_vec<vec_expr<Expr> >,
1344  vec_expr<Expr>,
1345  is_vec<T >,
1346  T,
1347  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, vec_domain>
1348  ::impl<const vec_expr<Expr>&, const T&>::result_type const
1349 >::type
1350 operator* (const vec_expr<Expr>& l, const T& r)
1351 {
1352  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, vec_domain>
1353  ::impl<const vec_expr<Expr>&, const T&>() (l, r);
1354 }
1355 #else // BOOST_VERSION >= 104601
1356 typename boost::proto::detail::enable_binary<
1357  vec_domain,
1358  vec_domain::proto_grammar,
1359  boost::mpl::and_<
1360  boost::mpl::or_<is_vec<vec_expr<Expr> >, is_vec<T > >,
1361  boost::mpl::not_<
1362  boost::mpl::or_<
1363  boost::proto::is_extension<vec_expr<Expr> >,
1364  boost::proto::is_extension<T >
1365  >
1366  >
1367  >,
1368  boost::proto::tag::multiplies,
1369  vec_expr<Expr> const &,
1370  T const &
1371 >::type /* const */
1372 operator* (vec_expr<Expr> const &left, T const &right)
1373 {
1374  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, vec_domain, vec_expr<Expr> const &, T const &>()(left, right);
1375 }
1376 #endif // BOOST_VERSION
1377 template<class T1, class T2, class M>
1378 #if BOOST_VERSION < 104601
1379 typename
1380 boost::proto::detail::enable_binary<
1381  vec_domain,
1382  is_vec<vec<T1,M> >,
1383  vec<T1,M>,
1384  is_vec<vec<T2,M> >,
1385  vec<T2,M>,
1386  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, vec_domain>
1387  ::impl<const vec<T1,M>&, const vec<T2,M>&>::result_type const
1388 >::type
1389 operator* (const vec<T1,M>& l, const vec<T2,M>& r)
1390 {
1391  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, vec_domain>
1392  ::impl<const vec<T1,M>&, const vec<T2,M>&>() (l, r);
1393 }
1394 #else // BOOST_VERSION >= 104601
1395 typename boost::proto::detail::enable_binary<
1396  vec_domain,
1397  vec_domain::proto_grammar,
1398  boost::mpl::and_<
1399  boost::mpl::or_<is_vec<vec<T1,M> >, is_vec<vec<T2,M> > >,
1400  boost::mpl::not_<
1401  boost::mpl::or_<
1402  boost::proto::is_extension<vec<T1,M> >,
1403  boost::proto::is_extension<vec<T2,M> >
1404  >
1405  >
1406  >,
1407  boost::proto::tag::multiplies,
1408  vec<T1,M> const &,
1409  vec<T2,M> const &
1410 >::type /* const */
1411 operator* (vec<T1,M> const &left, vec<T2,M> const &right)
1412 {
1413  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, vec_domain, vec<T1,M> const &, vec<T2,M> const &>()(left, right);
1414 }
1415 #endif // BOOST_VERSION
1416 template<class T, class M, class Expr>
1417 #if BOOST_VERSION < 104601
1418 typename
1419 boost::proto::detail::enable_binary<
1420  vec_domain,
1421  is_vec<vec<T,M> >,
1422  vec<T,M>,
1423  is_vec<vec_expr<Expr> >,
1424  vec_expr<Expr>,
1425  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, vec_domain>
1426  ::impl<const vec<T,M>&, const vec_expr<Expr>&>::result_type const
1427 >::type
1429 {
1430  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, vec_domain>
1431  ::impl<const vec<T,M>&, const vec_expr<Expr>&>() (l, r);
1432 }
1433 #else // BOOST_VERSION >= 104601
1434 typename boost::proto::detail::enable_binary<
1435  vec_domain,
1436  vec_domain::proto_grammar,
1437  boost::mpl::and_<
1438  boost::mpl::or_<is_vec<vec<T,M> >, is_vec<vec_expr<Expr> > >,
1439  boost::mpl::not_<
1440  boost::mpl::or_<
1441  boost::proto::is_extension<vec<T,M> >,
1442  boost::proto::is_extension<vec_expr<Expr> >
1443  >
1444  >
1445  >,
1446  boost::proto::tag::multiplies,
1447  vec<T,M> const &,
1448  vec_expr<Expr> const &
1449 >::type /* const */
1450 operator* (vec<T,M> const &left, vec_expr<Expr> const &right)
1451 {
1452  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, vec_domain, vec<T,M> const &, vec_expr<Expr> const &>()(left, right);
1453 }
1454 #endif // BOOST_VERSION
1455 template<class T, class M, class Expr>
1456 #if BOOST_VERSION < 104601
1457 typename
1458 boost::proto::detail::enable_binary<
1459  vec_domain,
1460  is_vec<vec_expr<Expr> >,
1461  vec_expr<Expr>,
1462  is_vec<vec<T,M> >,
1463  vec<T,M>,
1464  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, vec_domain>
1465  ::impl<const vec_expr<Expr>&, const vec<T,M>&>::result_type const
1466 >::type
1468 {
1469  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, vec_domain>
1470  ::impl<const vec_expr<Expr>&, const vec<T,M>&>() (l, r);
1471 }
1472 #else // BOOST_VERSION >= 104601
1473 typename boost::proto::detail::enable_binary<
1474  vec_domain,
1475  vec_domain::proto_grammar,
1476  boost::mpl::and_<
1477  boost::mpl::or_<is_vec<vec_expr<Expr> >, is_vec<vec<T,M> > >,
1478  boost::mpl::not_<
1479  boost::mpl::or_<
1480  boost::proto::is_extension<vec_expr<Expr> >,
1481  boost::proto::is_extension<vec<T,M> >
1482  >
1483  >
1484  >,
1485  boost::proto::tag::multiplies,
1486  vec_expr<Expr> const &,
1487  vec<T,M> const &
1488 >::type /* const */
1489 operator* (vec_expr<Expr> const &left, vec<T,M> const &right)
1490 {
1491  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, vec_domain, vec_expr<Expr> const &, vec<T,M> const &>()(left, right);
1492 }
1493 #endif // BOOST_VERSION
1494 template<class Expr1, class Expr2>
1495 #if BOOST_VERSION < 104601
1496 typename
1497 boost::proto::detail::enable_binary<
1498  vec_domain,
1499  is_vec<vec_expr<Expr1> >,
1500  vec_expr<Expr1>,
1501  is_vec<vec_expr<Expr2> >,
1502  vec_expr<Expr2>,
1503  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, vec_domain>
1504  ::impl<const vec_expr<Expr1>&, const vec_expr<Expr2>&>::result_type const
1505 >::type
1507 {
1508  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, vec_domain>
1509  ::impl<const vec_expr<Expr1>&, const vec_expr<Expr2>&>() (l, r);
1510 }
1511 #else // BOOST_VERSION >= 104601
1512 typename boost::proto::detail::enable_binary<
1513  vec_domain,
1514  vec_domain::proto_grammar,
1515  boost::mpl::and_<
1516  boost::mpl::or_<is_vec<vec_expr<Expr1> >, is_vec<vec_expr<Expr2> > >,
1517  boost::mpl::not_<
1518  boost::mpl::or_<
1519  boost::proto::is_extension<vec_expr<Expr1> >,
1520  boost::proto::is_extension<vec_expr<Expr2> >
1521  >
1522  >
1523  >,
1524  boost::proto::tag::multiplies,
1525  vec_expr<Expr1> const &,
1526  vec_expr<Expr2> const &
1527 >::type /* const */
1528 operator* (vec_expr<Expr1> const &left, vec_expr<Expr2> const &right)
1529 {
1530  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, vec_domain, vec_expr<Expr1> const &, vec_expr<Expr2> const &>()(left, right);
1531 }
1532 #endif // BOOST_VERSION
1533 template<class T, class M>
1534 #if BOOST_VERSION < 104601
1535 typename
1536 boost::proto::detail::enable_binary<
1537  vec_domain,
1538  is_vec<int >,
1539  int,
1540  is_vec<vec<T,M> >,
1541  vec<T,M>,
1542  typename boost::proto::functional::make_expr<boost::proto::tag::divides, vec_domain>
1543  ::impl<const int&, const vec<T,M>&>::result_type const
1544 >::type
1545 operator/ (const int& l, const vec<T,M>& r)
1546 {
1547  return boost::proto::functional::make_expr<boost::proto::tag::divides, vec_domain>
1548  ::impl<const int&, const vec<T,M>&>() (l, r);
1549 }
1550 #else // BOOST_VERSION >= 104601
1551 typename boost::proto::detail::enable_binary<
1552  vec_domain,
1553  vec_domain::proto_grammar,
1554  boost::mpl::and_<
1555  boost::mpl::or_<is_vec<int >, is_vec<vec<T,M> > >,
1556  boost::mpl::not_<
1557  boost::mpl::or_<
1558  boost::proto::is_extension<int >,
1559  boost::proto::is_extension<vec<T,M> >
1560  >
1561  >
1562  >,
1563  boost::proto::tag::divides,
1564  int const &,
1565  vec<T,M> const &
1566 >::type /* const */
1567 operator/ (int const &left, vec<T,M> const &right)
1568 {
1569  return boost::proto::detail::make_expr_<boost::proto::tag::divides, vec_domain, int const &, vec<T,M> const &>()(left, right);
1570 }
1571 #endif // BOOST_VERSION
1572 template<class T, class M>
1573 #if BOOST_VERSION < 104601
1574 typename
1575 boost::proto::detail::enable_binary<
1576  vec_domain,
1577  is_vec<T >,
1578  T,
1579  is_vec<vec<T,M> >,
1580  vec<T,M>,
1581  typename boost::proto::functional::make_expr<boost::proto::tag::divides, vec_domain>
1582  ::impl<const T&, const vec<T,M>&>::result_type const
1583 >::type
1584 operator/ (const T& l, const vec<T,M>& r)
1585 {
1586  return boost::proto::functional::make_expr<boost::proto::tag::divides, vec_domain>
1587  ::impl<const T&, const vec<T,M>&>() (l, r);
1588 }
1589 #else // BOOST_VERSION >= 104601
1590 typename boost::proto::detail::enable_binary<
1591  vec_domain,
1592  vec_domain::proto_grammar,
1593  boost::mpl::and_<
1594  boost::mpl::or_<is_vec<T >, is_vec<vec<T,M> > >,
1595  boost::mpl::not_<
1596  boost::mpl::or_<
1597  boost::proto::is_extension<T >,
1598  boost::proto::is_extension<vec<T,M> >
1599  >
1600  >
1601  >,
1602  boost::proto::tag::divides,
1603  T const &,
1604  vec<T,M> const &
1605 >::type /* const */
1606 operator/ (T const &left, vec<T,M> const &right)
1607 {
1608  return boost::proto::detail::make_expr_<boost::proto::tag::divides, vec_domain, T const &, vec<T,M> const &>()(left, right);
1609 }
1610 #endif // BOOST_VERSION
1611 template<class T, class M>
1612 #if BOOST_VERSION < 104601
1613 typename
1614 boost::proto::detail::enable_binary<
1615  vec_domain,
1616  is_vec<vec<T,M> >,
1617  vec<T,M>,
1618  is_vec<int >,
1619  int,
1620  typename boost::proto::functional::make_expr<boost::proto::tag::divides, vec_domain>
1621  ::impl<const vec<T,M>&, const int&>::result_type const
1622 >::type
1623 operator/ (const vec<T,M>& l, const int& r)
1624 {
1625  return boost::proto::functional::make_expr<boost::proto::tag::divides, vec_domain>
1626  ::impl<const vec<T,M>&, const int&>() (l, r);
1627 }
1628 #else // BOOST_VERSION >= 104601
1629 typename boost::proto::detail::enable_binary<
1630  vec_domain,
1631  vec_domain::proto_grammar,
1632  boost::mpl::and_<
1633  boost::mpl::or_<is_vec<vec<T,M> >, is_vec<int > >,
1634  boost::mpl::not_<
1635  boost::mpl::or_<
1636  boost::proto::is_extension<vec<T,M> >,
1637  boost::proto::is_extension<int >
1638  >
1639  >
1640  >,
1641  boost::proto::tag::divides,
1642  vec<T,M> const &,
1643  int const &
1644 >::type /* const */
1645 operator/ (vec<T,M> const &left, int const &right)
1646 {
1647  return boost::proto::detail::make_expr_<boost::proto::tag::divides, vec_domain, vec<T,M> const &, int const &>()(left, right);
1648 }
1649 #endif // BOOST_VERSION
1650 template<class T, class M>
1651 #if BOOST_VERSION < 104601
1652 typename
1653 boost::proto::detail::enable_binary<
1654  vec_domain,
1655  is_vec<vec<T,M> >,
1656  vec<T,M>,
1657  is_vec<T >,
1658  T,
1659  typename boost::proto::functional::make_expr<boost::proto::tag::divides, vec_domain>
1660  ::impl<const vec<T,M>&, const T&>::result_type const
1661 >::type
1662 operator/ (const vec<T,M>& l, const T& r)
1663 {
1664  return boost::proto::functional::make_expr<boost::proto::tag::divides, vec_domain>
1665  ::impl<const vec<T,M>&, const T&>() (l, r);
1666 }
1667 #else // BOOST_VERSION >= 104601
1668 typename boost::proto::detail::enable_binary<
1669  vec_domain,
1670  vec_domain::proto_grammar,
1671  boost::mpl::and_<
1672  boost::mpl::or_<is_vec<vec<T,M> >, is_vec<T > >,
1673  boost::mpl::not_<
1674  boost::mpl::or_<
1675  boost::proto::is_extension<vec<T,M> >,
1676  boost::proto::is_extension<T >
1677  >
1678  >
1679  >,
1680  boost::proto::tag::divides,
1681  vec<T,M> const &,
1682  T const &
1683 >::type /* const */
1684 operator/ (vec<T,M> const &left, T const &right)
1685 {
1686  return boost::proto::detail::make_expr_<boost::proto::tag::divides, vec_domain, vec<T,M> const &, T const &>()(left, right);
1687 }
1688 #endif // BOOST_VERSION
1689 template<class Expr>
1690 #if BOOST_VERSION < 104601
1691 typename
1692 boost::proto::detail::enable_binary<
1693  vec_domain,
1694  is_vec<int >,
1695  int,
1696  is_vec<vec_expr<Expr> >,
1697  vec_expr<Expr>,
1698  typename boost::proto::functional::make_expr<boost::proto::tag::divides, vec_domain>
1699  ::impl<const int&, const vec_expr<Expr>&>::result_type const
1700 >::type
1701 operator/ (const int& l, const vec_expr<Expr>& r)
1702 {
1703  return boost::proto::functional::make_expr<boost::proto::tag::divides, vec_domain>
1704  ::impl<const int&, const vec_expr<Expr>&>() (l, r);
1705 }
1706 #else // BOOST_VERSION >= 104601
1707 typename boost::proto::detail::enable_binary<
1708  vec_domain,
1709  vec_domain::proto_grammar,
1710  boost::mpl::and_<
1711  boost::mpl::or_<is_vec<int >, is_vec<vec_expr<Expr> > >,
1712  boost::mpl::not_<
1713  boost::mpl::or_<
1714  boost::proto::is_extension<int >,
1715  boost::proto::is_extension<vec_expr<Expr> >
1716  >
1717  >
1718  >,
1719  boost::proto::tag::divides,
1720  int const &,
1721  vec_expr<Expr> const &
1722 >::type /* const */
1723 operator/ (int const &left, vec_expr<Expr> const &right)
1724 {
1725  return boost::proto::detail::make_expr_<boost::proto::tag::divides, vec_domain, int const &, vec_expr<Expr> const &>()(left, right);
1726 }
1727 #endif // BOOST_VERSION
1728 template<class Expr>
1729 #if BOOST_VERSION < 104601
1730 typename
1731 boost::proto::detail::enable_binary<
1732  vec_domain,
1733  is_vec<vec_expr<Expr> >,
1734  vec_expr<Expr>,
1735  is_vec<int >,
1736  int,
1737  typename boost::proto::functional::make_expr<boost::proto::tag::divides, vec_domain>
1738  ::impl<const vec_expr<Expr>&, const int&>::result_type const
1739 >::type
1740 operator/ (const vec_expr<Expr>& l, const int& r)
1741 {
1742  return boost::proto::functional::make_expr<boost::proto::tag::divides, vec_domain>
1743  ::impl<const vec_expr<Expr>&, const int&>() (l, r);
1744 }
1745 #else // BOOST_VERSION >= 104601
1746 typename boost::proto::detail::enable_binary<
1747  vec_domain,
1748  vec_domain::proto_grammar,
1749  boost::mpl::and_<
1750  boost::mpl::or_<is_vec<vec_expr<Expr> >, is_vec<int > >,
1751  boost::mpl::not_<
1752  boost::mpl::or_<
1753  boost::proto::is_extension<vec_expr<Expr> >,
1754  boost::proto::is_extension<int >
1755  >
1756  >
1757  >,
1758  boost::proto::tag::divides,
1759  vec_expr<Expr> const &,
1760  int const &
1761 >::type /* const */
1762 operator/ (vec_expr<Expr> const &left, int const &right)
1763 {
1764  return boost::proto::detail::make_expr_<boost::proto::tag::divides, vec_domain, vec_expr<Expr> const &, int const &>()(left, right);
1765 }
1766 #endif // BOOST_VERSION
1767 template<class T, class Expr>
1768 #if BOOST_VERSION < 104601
1769 typename
1770 boost::proto::detail::enable_binary<
1771  vec_domain,
1772  is_vec<T >,
1773  T,
1774  is_vec<vec_expr<Expr> >,
1775  vec_expr<Expr>,
1776  typename boost::proto::functional::make_expr<boost::proto::tag::divides, vec_domain>
1777  ::impl<const T&, const vec_expr<Expr>&>::result_type const
1778 >::type
1779 operator/ (const T& l, const vec_expr<Expr>& r)
1780 {
1781  return boost::proto::functional::make_expr<boost::proto::tag::divides, vec_domain>
1782  ::impl<const T&, const vec_expr<Expr>&>() (l, r);
1783 }
1784 #else // BOOST_VERSION >= 104601
1785 typename boost::proto::detail::enable_binary<
1786  vec_domain,
1787  vec_domain::proto_grammar,
1788  boost::mpl::and_<
1789  boost::mpl::or_<is_vec<T >, is_vec<vec_expr<Expr> > >,
1790  boost::mpl::not_<
1791  boost::mpl::or_<
1792  boost::proto::is_extension<T >,
1793  boost::proto::is_extension<vec_expr<Expr> >
1794  >
1795  >
1796  >,
1797  boost::proto::tag::divides,
1798  T const &,
1799  vec_expr<Expr> const &
1800 >::type /* const */
1801 operator/ (T const &left, vec_expr<Expr> const &right)
1802 {
1803  return boost::proto::detail::make_expr_<boost::proto::tag::divides, vec_domain, T const &, vec_expr<Expr> const &>()(left, right);
1804 }
1805 #endif // BOOST_VERSION
1806 template<class T, class Expr>
1807 #if BOOST_VERSION < 104601
1808 typename
1809 boost::proto::detail::enable_binary<
1810  vec_domain,
1811  is_vec<vec_expr<Expr> >,
1812  vec_expr<Expr>,
1813  is_vec<T >,
1814  T,
1815  typename boost::proto::functional::make_expr<boost::proto::tag::divides, vec_domain>
1816  ::impl<const vec_expr<Expr>&, const T&>::result_type const
1817 >::type
1818 operator/ (const vec_expr<Expr>& l, const T& r)
1819 {
1820  return boost::proto::functional::make_expr<boost::proto::tag::divides, vec_domain>
1821  ::impl<const vec_expr<Expr>&, const T&>() (l, r);
1822 }
1823 #else // BOOST_VERSION >= 104601
1824 typename boost::proto::detail::enable_binary<
1825  vec_domain,
1826  vec_domain::proto_grammar,
1827  boost::mpl::and_<
1828  boost::mpl::or_<is_vec<vec_expr<Expr> >, is_vec<T > >,
1829  boost::mpl::not_<
1830  boost::mpl::or_<
1831  boost::proto::is_extension<vec_expr<Expr> >,
1832  boost::proto::is_extension<T >
1833  >
1834  >
1835  >,
1836  boost::proto::tag::divides,
1837  vec_expr<Expr> const &,
1838  T const &
1839 >::type /* const */
1840 operator/ (vec_expr<Expr> const &left, T const &right)
1841 {
1842  return boost::proto::detail::make_expr_<boost::proto::tag::divides, vec_domain, vec_expr<Expr> const &, T const &>()(left, right);
1843 }
1844 #endif // BOOST_VERSION
1845 template<class T1, class T2, class M>
1846 #if BOOST_VERSION < 104601
1847 typename
1848 boost::proto::detail::enable_binary<
1849  vec_domain,
1850  is_vec<vec<T1,M> >,
1851  vec<T1,M>,
1852  is_vec<vec<T2,M> >,
1853  vec<T2,M>,
1854  typename boost::proto::functional::make_expr<boost::proto::tag::divides, vec_domain>
1855  ::impl<const vec<T1,M>&, const vec<T2,M>&>::result_type const
1856 >::type
1857 operator/ (const vec<T1,M>& l, const vec<T2,M>& r)
1858 {
1859  return boost::proto::functional::make_expr<boost::proto::tag::divides, vec_domain>
1860  ::impl<const vec<T1,M>&, const vec<T2,M>&>() (l, r);
1861 }
1862 #else // BOOST_VERSION >= 104601
1863 typename boost::proto::detail::enable_binary<
1864  vec_domain,
1865  vec_domain::proto_grammar,
1866  boost::mpl::and_<
1867  boost::mpl::or_<is_vec<vec<T1,M> >, is_vec<vec<T2,M> > >,
1868  boost::mpl::not_<
1869  boost::mpl::or_<
1870  boost::proto::is_extension<vec<T1,M> >,
1871  boost::proto::is_extension<vec<T2,M> >
1872  >
1873  >
1874  >,
1875  boost::proto::tag::divides,
1876  vec<T1,M> const &,
1877  vec<T2,M> const &
1878 >::type /* const */
1879 operator/ (vec<T1,M> const &left, vec<T2,M> const &right)
1880 {
1881  return boost::proto::detail::make_expr_<boost::proto::tag::divides, vec_domain, vec<T1,M> const &, vec<T2,M> const &>()(left, right);
1882 }
1883 #endif // BOOST_VERSION
1884 template<class T, class M, class Expr>
1885 #if BOOST_VERSION < 104601
1886 typename
1887 boost::proto::detail::enable_binary<
1888  vec_domain,
1889  is_vec<vec<T,M> >,
1890  vec<T,M>,
1891  is_vec<vec_expr<Expr> >,
1892  vec_expr<Expr>,
1893  typename boost::proto::functional::make_expr<boost::proto::tag::divides, vec_domain>
1894  ::impl<const vec<T,M>&, const vec_expr<Expr>&>::result_type const
1895 >::type
1897 {
1898  return boost::proto::functional::make_expr<boost::proto::tag::divides, vec_domain>
1899  ::impl<const vec<T,M>&, const vec_expr<Expr>&>() (l, r);
1900 }
1901 #else // BOOST_VERSION >= 104601
1902 typename boost::proto::detail::enable_binary<
1903  vec_domain,
1904  vec_domain::proto_grammar,
1905  boost::mpl::and_<
1906  boost::mpl::or_<is_vec<vec<T,M> >, is_vec<vec_expr<Expr> > >,
1907  boost::mpl::not_<
1908  boost::mpl::or_<
1909  boost::proto::is_extension<vec<T,M> >,
1910  boost::proto::is_extension<vec_expr<Expr> >
1911  >
1912  >
1913  >,
1914  boost::proto::tag::divides,
1915  vec<T,M> const &,
1916  vec_expr<Expr> const &
1917 >::type /* const */
1918 operator/ (vec<T,M> const &left, vec_expr<Expr> const &right)
1919 {
1920  return boost::proto::detail::make_expr_<boost::proto::tag::divides, vec_domain, vec<T,M> const &, vec_expr<Expr> const &>()(left, right);
1921 }
1922 #endif // BOOST_VERSION
1923 template<class T, class M, class Expr>
1924 #if BOOST_VERSION < 104601
1925 typename
1926 boost::proto::detail::enable_binary<
1927  vec_domain,
1928  is_vec<vec_expr<Expr> >,
1929  vec_expr<Expr>,
1930  is_vec<vec<T,M> >,
1931  vec<T,M>,
1932  typename boost::proto::functional::make_expr<boost::proto::tag::divides, vec_domain>
1933  ::impl<const vec_expr<Expr>&, const vec<T,M>&>::result_type const
1934 >::type
1936 {
1937  return boost::proto::functional::make_expr<boost::proto::tag::divides, vec_domain>
1938  ::impl<const vec_expr<Expr>&, const vec<T,M>&>() (l, r);
1939 }
1940 #else // BOOST_VERSION >= 104601
1941 typename boost::proto::detail::enable_binary<
1942  vec_domain,
1943  vec_domain::proto_grammar,
1944  boost::mpl::and_<
1945  boost::mpl::or_<is_vec<vec_expr<Expr> >, is_vec<vec<T,M> > >,
1946  boost::mpl::not_<
1947  boost::mpl::or_<
1948  boost::proto::is_extension<vec_expr<Expr> >,
1949  boost::proto::is_extension<vec<T,M> >
1950  >
1951  >
1952  >,
1953  boost::proto::tag::divides,
1954  vec_expr<Expr> const &,
1955  vec<T,M> const &
1956 >::type /* const */
1957 operator/ (vec_expr<Expr> const &left, vec<T,M> const &right)
1958 {
1959  return boost::proto::detail::make_expr_<boost::proto::tag::divides, vec_domain, vec_expr<Expr> const &, vec<T,M> const &>()(left, right);
1960 }
1961 #endif // BOOST_VERSION
1962 template<class Expr1, class Expr2>
1963 #if BOOST_VERSION < 104601
1964 typename
1965 boost::proto::detail::enable_binary<
1966  vec_domain,
1967  is_vec<vec_expr<Expr1> >,
1968  vec_expr<Expr1>,
1969  is_vec<vec_expr<Expr2> >,
1970  vec_expr<Expr2>,
1971  typename boost::proto::functional::make_expr<boost::proto::tag::divides, vec_domain>
1972  ::impl<const vec_expr<Expr1>&, const vec_expr<Expr2>&>::result_type const
1973 >::type
1975 {
1976  return boost::proto::functional::make_expr<boost::proto::tag::divides, vec_domain>
1977  ::impl<const vec_expr<Expr1>&, const vec_expr<Expr2>&>() (l, r);
1978 }
1979 #else // BOOST_VERSION >= 104601
1980 typename boost::proto::detail::enable_binary<
1981  vec_domain,
1982  vec_domain::proto_grammar,
1983  boost::mpl::and_<
1984  boost::mpl::or_<is_vec<vec_expr<Expr1> >, is_vec<vec_expr<Expr2> > >,
1985  boost::mpl::not_<
1986  boost::mpl::or_<
1987  boost::proto::is_extension<vec_expr<Expr1> >,
1988  boost::proto::is_extension<vec_expr<Expr2> >
1989  >
1990  >
1991  >,
1992  boost::proto::tag::divides,
1993  vec_expr<Expr1> const &,
1994  vec_expr<Expr2> const &
1995 >::type /* const */
1996 operator/ (vec_expr<Expr1> const &left, vec_expr<Expr2> const &right)
1997 {
1998  return boost::proto::detail::make_expr_<boost::proto::tag::divides, vec_domain, vec_expr<Expr1> const &, vec_expr<Expr2> const &>()(left, right);
1999 }
2000 #endif // BOOST_VERSION
2001 namespace vec_detail {
2002  struct plus_assign {
2003  template<class T, class U>
2004  void operator() (T &t, const U &u) const { t += u; }
2005  };
2006 } // namespace vec_detail
2007 template<class T, class M>
2008 vec<T,M>&
2009 operator+= (vec<T,M>& l, const int& r)
2010 {
2011  vec_detail::evaluate (l.begin(), l.end(), proto::as_expr<vec_domain>(r), vec_detail::plus_assign());
2012  return l;
2013 }
2014 template<class T, class M>
2015 vec<T,M>&
2016 operator+= (vec<T,M>& l, const T& r)
2017 {
2018  vec_detail::evaluate (l.begin(), l.end(), proto::as_expr<vec_domain>(r), vec_detail::plus_assign());
2019  return l;
2020 }
2021 template<class T1, class T2, class M>
2022 vec<T1,M>&
2024 {
2025  check_macro (l.size() == r.size(), "incompatible spaces " << l.size()
2026  << " and " << r.size() << " in vec += expression");
2027  vec_detail::evaluate (l.begin(), l.end(), proto::as_expr<vec_domain>(r), vec_detail::plus_assign());
2028  return l;
2029 }
2030 template<class T, class M, class Expr>
2031 vec<T,M>&
2033 {
2034  const vec_check_size_context check_size (l.size());
2035  proto::eval (proto::as_expr<vec_domain>(r), check_size);
2036  vec_detail::evaluate (l.begin(), l.end(), proto::as_expr<vec_domain>(r), vec_detail::plus_assign());
2037  return l;
2038 }
2039 namespace vec_detail {
2040  struct minus_assign {
2041  template<class T, class U>
2042  void operator() (T &t, const U &u) const { t -= u; }
2043  };
2044 } // namespace vec_detail
2045 template<class T, class M>
2046 vec<T,M>&
2047 operator-= (vec<T,M>& l, const int& r)
2048 {
2049  vec_detail::evaluate (l.begin(), l.end(), proto::as_expr<vec_domain>(r), vec_detail::minus_assign());
2050  return l;
2051 }
2052 template<class T, class M>
2053 vec<T,M>&
2054 operator-= (vec<T,M>& l, const T& r)
2055 {
2056  vec_detail::evaluate (l.begin(), l.end(), proto::as_expr<vec_domain>(r), vec_detail::minus_assign());
2057  return l;
2058 }
2059 template<class T1, class T2, class M>
2060 vec<T1,M>&
2062 {
2063  check_macro (l.size() == r.size(), "incompatible spaces " << l.size()
2064  << " and " << r.size() << " in vec -= expression");
2065  vec_detail::evaluate (l.begin(), l.end(), proto::as_expr<vec_domain>(r), vec_detail::minus_assign());
2066  return l;
2067 }
2068 template<class T, class M, class Expr>
2069 vec<T,M>&
2071 {
2072  const vec_check_size_context check_size (l.size());
2073  proto::eval (proto::as_expr<vec_domain>(r), check_size);
2074  vec_detail::evaluate (l.begin(), l.end(), proto::as_expr<vec_domain>(r), vec_detail::minus_assign());
2075  return l;
2076 }
2077 namespace vec_detail {
2079  template<class T, class U>
2080  void operator() (T &t, const U &u) const { t *= u; }
2081  };
2082 } // namespace vec_detail
2083 template<class T, class M>
2084 vec<T,M>&
2085 operator*= (vec<T,M>& l, const int& r)
2086 {
2087  vec_detail::evaluate (l.begin(), l.end(), proto::as_expr<vec_domain>(r), vec_detail::multiplies_assign());
2088  return l;
2089 }
2090 template<class T, class M>
2091 vec<T,M>&
2092 operator*= (vec<T,M>& l, const T& r)
2093 {
2094  vec_detail::evaluate (l.begin(), l.end(), proto::as_expr<vec_domain>(r), vec_detail::multiplies_assign());
2095  return l;
2096 }
2097 template<class T1, class T2, class M>
2098 vec<T1,M>&
2100 {
2101  check_macro (l.size() == r.size(), "incompatible spaces " << l.size()
2102  << " and " << r.size() << " in vec *= expression");
2103  vec_detail::evaluate (l.begin(), l.end(), proto::as_expr<vec_domain>(r), vec_detail::multiplies_assign());
2104  return l;
2105 }
2106 template<class T, class M, class Expr>
2107 vec<T,M>&
2109 {
2110  const vec_check_size_context check_size (l.size());
2111  proto::eval (proto::as_expr<vec_domain>(r), check_size);
2112  vec_detail::evaluate (l.begin(), l.end(), proto::as_expr<vec_domain>(r), vec_detail::multiplies_assign());
2113  return l;
2114 }
2115 namespace vec_detail {
2117  template<class T, class U>
2118  void operator() (T &t, const U &u) const { t /= u; }
2119  };
2120 } // namespace vec_detail
2121 template<class T, class M>
2122 vec<T,M>&
2123 operator/= (vec<T,M>& l, const int& r)
2124 {
2125  vec_detail::evaluate (l.begin(), l.end(), proto::as_expr<vec_domain>(r), vec_detail::divides_assign());
2126  return l;
2127 }
2128 template<class T, class M>
2129 vec<T,M>&
2130 operator/= (vec<T,M>& l, const T& r)
2131 {
2132  vec_detail::evaluate (l.begin(), l.end(), proto::as_expr<vec_domain>(r), vec_detail::divides_assign());
2133  return l;
2134 }
2135 template<class T1, class T2, class M>
2136 vec<T1,M>&
2138 {
2139  check_macro (l.size() == r.size(), "incompatible spaces " << l.size()
2140  << " and " << r.size() << " in vec /= expression");
2141  vec_detail::evaluate (l.begin(), l.end(), proto::as_expr<vec_domain>(r), vec_detail::divides_assign());
2142  return l;
2143 }
2144 template<class T, class M, class Expr>
2145 vec<T,M>&
2147 {
2148  const vec_check_size_context check_size (l.size());
2149  proto::eval (proto::as_expr<vec_domain>(r), check_size);
2150  vec_detail::evaluate (l.begin(), l.end(), proto::as_expr<vec_domain>(r), vec_detail::divides_assign());
2151  return l;
2152 }
2153 namespace vec_detail {
2154  struct abs_ {
2155  template<class Sig>
2156  struct result;
2157 
2158  template<class This, class T>
2159  struct result<This(T)> : boost::remove_const<typename boost::remove_reference<T>::type> {};
2160 
2161  template<class T>
2162  T operator() (const T& x) const { return abs(x); }
2163  };
2164 } // namespace vec_detail
2165 template<class T, class M>
2166 typename boost::proto::result_of::make_expr<
2167  boost::proto::tag::function,
2168  vec_domain,
2169  const vec_detail::abs_,
2170  const vec<T,M>&
2171  >::type
2172 abs (const vec<T,M>& x)
2173 {
2174  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::abs_(), boost::ref(x));
2175 }
2176 template<class Expr>
2177 typename boost::proto::result_of::make_expr<
2178  boost::proto::tag::function,
2179  vec_domain,
2180  const vec_detail::abs_,
2181  const vec_expr<Expr>&
2182  >::type
2184 {
2185  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::abs_(), boost::ref(x));
2186 }
2187 namespace vec_detail {
2188  struct fabs_ {
2189  template<class Sig>
2190  struct result;
2191 
2192  template<class This, class T>
2193  struct result<This(T)> : boost::remove_const<typename boost::remove_reference<T>::type> {};
2194 
2195  template<class T>
2196  T operator() (const T& x) const { return fabs(x); }
2197  };
2198 } // namespace vec_detail
2199 template<class T, class M>
2200 typename boost::proto::result_of::make_expr<
2201  boost::proto::tag::function,
2202  vec_domain,
2203  const vec_detail::fabs_,
2204  const vec<T,M>&
2205  >::type
2206 fabs (const vec<T,M>& x)
2207 {
2208  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::fabs_(), boost::ref(x));
2209 }
2210 template<class Expr>
2211 typename boost::proto::result_of::make_expr<
2212  boost::proto::tag::function,
2213  vec_domain,
2214  const vec_detail::fabs_,
2215  const vec_expr<Expr>&
2216  >::type
2218 {
2219  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::fabs_(), boost::ref(x));
2220 }
2221 namespace vec_detail {
2222  struct floor_ {
2223  template<class Sig>
2224  struct result;
2225 
2226  template<class This, class T>
2227  struct result<This(T)> : boost::remove_const<typename boost::remove_reference<T>::type> {};
2228 
2229  template<class T>
2230  T operator() (const T& x) const { return floor(x); }
2231  };
2232 } // namespace vec_detail
2233 template<class T, class M>
2234 typename boost::proto::result_of::make_expr<
2235  boost::proto::tag::function,
2236  vec_domain,
2237  const vec_detail::floor_,
2238  const vec<T,M>&
2239  >::type
2240 floor (const vec<T,M>& x)
2241 {
2242  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::floor_(), boost::ref(x));
2243 }
2244 template<class Expr>
2245 typename boost::proto::result_of::make_expr<
2246  boost::proto::tag::function,
2247  vec_domain,
2248  const vec_detail::floor_,
2249  const vec_expr<Expr>&
2250  >::type
2252 {
2253  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::floor_(), boost::ref(x));
2254 }
2255 namespace vec_detail {
2256  struct ceil_ {
2257  template<class Sig>
2258  struct result;
2259 
2260  template<class This, class T>
2261  struct result<This(T)> : boost::remove_const<typename boost::remove_reference<T>::type> {};
2262 
2263  template<class T>
2264  T operator() (const T& x) const { return ceil(x); }
2265  };
2266 } // namespace vec_detail
2267 template<class T, class M>
2268 typename boost::proto::result_of::make_expr<
2269  boost::proto::tag::function,
2270  vec_domain,
2271  const vec_detail::ceil_,
2272  const vec<T,M>&
2273  >::type
2274 ceil (const vec<T,M>& x)
2275 {
2276  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::ceil_(), boost::ref(x));
2277 }
2278 template<class Expr>
2279 typename boost::proto::result_of::make_expr<
2280  boost::proto::tag::function,
2281  vec_domain,
2282  const vec_detail::ceil_,
2283  const vec_expr<Expr>&
2284  >::type
2286 {
2287  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::ceil_(), boost::ref(x));
2288 }
2289 namespace vec_detail {
2290  struct sqr_ {
2291  template<class Sig>
2292  struct result;
2293 
2294  template<class This, class T>
2295  struct result<This(T)> : boost::remove_const<typename boost::remove_reference<T>::type> {};
2296 
2297  template<class T>
2298  T operator() (const T& x) const { return sqr(x); }
2299  };
2300 } // namespace vec_detail
2301 template<class T, class M>
2302 typename boost::proto::result_of::make_expr<
2303  boost::proto::tag::function,
2304  vec_domain,
2305  const vec_detail::sqr_,
2306  const vec<T,M>&
2307  >::type
2308 sqr (const vec<T,M>& x)
2309 {
2310  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::sqr_(), boost::ref(x));
2311 }
2312 template<class Expr>
2313 typename boost::proto::result_of::make_expr<
2314  boost::proto::tag::function,
2315  vec_domain,
2316  const vec_detail::sqr_,
2317  const vec_expr<Expr>&
2318  >::type
2320 {
2321  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::sqr_(), boost::ref(x));
2322 }
2323 namespace vec_detail {
2324  struct min_ {
2325  template<class Sig>
2326  struct result;
2327 
2328  template<class This, class U, class V>
2329  struct result<This(U,V)> : boost::remove_const<
2330  typename promote<
2331  typename boost::remove_const<typename boost::remove_reference<U>::type>::type,
2332  typename boost::remove_const<typename boost::remove_reference<V>::type>::type
2333  >::type> {};
2334 
2335  template<class U, class V>
2336  typename promote<
2337  typename boost::remove_const<typename boost::remove_reference<U>::type>::type,
2338  typename boost::remove_const<typename boost::remove_reference<V>::type>::type >::type
2339  operator() (const U& x, const V& y) const { return min(x,y); }
2340  };
2341 } // namespace vec_detail
2342 template<class T, class M>
2343 typename boost::proto::result_of::make_expr<
2344  boost::proto::tag::function,
2345  vec_domain,
2346  const vec_detail::min_,
2347  const int&,
2348  const vec<T,M>&
2349  >::type
2350 min (const int& x, const vec<T,M>& y)
2351 {
2352  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::min_(), boost::ref(x), boost::ref(y));
2353 }
2354 template<class T1, class T2, class M>
2355 typename boost::proto::result_of::make_expr<
2356  boost::proto::tag::function,
2357  vec_domain,
2358  const vec_detail::min_,
2359  const T1&,
2360  const vec<T2,M>&
2361  >::type
2362 min (const T1& x, const vec<T2,M>& y)
2363 {
2364  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::min_(), boost::ref(x), boost::ref(y));
2365 }
2366 template<class T, class M>
2367 typename boost::proto::result_of::make_expr<
2368  boost::proto::tag::function,
2369  vec_domain,
2370  const vec_detail::min_,
2371  const vec<T,M>&,
2372  const int&
2373  >::type
2374 min (const vec<T,M>& x, const int& y)
2375 {
2376  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::min_(), boost::ref(x), boost::ref(y));
2377 }
2378 template<class T1, class T2, class M>
2379 typename boost::proto::result_of::make_expr<
2380  boost::proto::tag::function,
2381  vec_domain,
2382  const vec_detail::min_,
2383  const vec<T1,M>&,
2384  const T2&
2385  >::type
2386 min (const vec<T1,M>& x, const T2& y)
2387 {
2388  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::min_(), boost::ref(x), boost::ref(y));
2389 }
2390 template<class T1, class T2, class M>
2391 typename boost::proto::result_of::make_expr<
2392  boost::proto::tag::function,
2393  vec_domain,
2394  const vec_detail::min_,
2395  const vec<T1,M>&,
2396  const vec<T2,M>&
2397  >::type
2398 min (const vec<T1,M>& x, const vec<T2,M>& y)
2399 {
2400  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::min_(), boost::ref(x), boost::ref(y));
2401 }
2402 template<class Expr>
2403 typename boost::proto::result_of::make_expr<
2404  boost::proto::tag::function,
2405  vec_domain,
2406  const vec_detail::min_,
2407  const int&,
2408  const vec_expr<Expr>&
2409  >::type
2410 min (const int& x, const vec_expr<Expr>& y)
2411 {
2412  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::min_(), boost::ref(x), boost::ref(y));
2413 }
2414 template<class T, class Expr>
2415 typename boost::proto::result_of::make_expr<
2416  boost::proto::tag::function,
2417  vec_domain,
2418  const vec_detail::min_,
2419  const T&,
2420  const vec_expr<Expr>&
2421  >::type
2422 min (const T& x, const vec_expr<Expr>& y)
2423 {
2424  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::min_(), boost::ref(x), boost::ref(y));
2425 }
2426 template<class Expr>
2427 typename boost::proto::result_of::make_expr<
2428  boost::proto::tag::function,
2429  vec_domain,
2430  const vec_detail::min_,
2431  const vec_expr<Expr>&,
2432  const int&
2433  >::type
2434 min (const vec_expr<Expr>& x, const int& y)
2435 {
2436  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::min_(), boost::ref(x), boost::ref(y));
2437 }
2438 template<class T, class Expr>
2439 typename boost::proto::result_of::make_expr<
2440  boost::proto::tag::function,
2441  vec_domain,
2442  const vec_detail::min_,
2443  const vec_expr<Expr>&,
2444  const T&
2445  >::type
2446 min (const vec_expr<Expr>& x, const T& y)
2447 {
2448  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::min_(), boost::ref(x), boost::ref(y));
2449 }
2450 template<class T, class M, class Expr>
2451 typename boost::proto::result_of::make_expr<
2452  boost::proto::tag::function,
2453  vec_domain,
2454  const vec_detail::min_,
2455  const vec<T,M>&,
2456  const vec_expr<Expr>&
2457  >::type
2458 min (const vec<T,M>& x, const vec_expr<Expr>& y)
2459 {
2460  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::min_(), boost::ref(x), boost::ref(y));
2461 }
2462 template<class T, class M, class Expr>
2463 typename boost::proto::result_of::make_expr<
2464  boost::proto::tag::function,
2465  vec_domain,
2466  const vec_detail::min_,
2467  const vec_expr<Expr>&,
2468  const vec<T,M>&
2469  >::type
2470 min (const vec_expr<Expr>& x, const vec<T,M>& y)
2471 {
2472  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::min_(), boost::ref(x), boost::ref(y));
2473 }
2474 template<class Expr1, class Expr2>
2475 typename boost::proto::result_of::make_expr<
2476  boost::proto::tag::function,
2477  vec_domain,
2478  const vec_detail::min_,
2479  const vec_expr<Expr1>&,
2480  const vec_expr<Expr2>&
2481  >::type
2483 {
2484  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::min_(), boost::ref(x), boost::ref(y));
2485 }
2486 namespace vec_detail {
2487  struct max_ {
2488  template<class Sig>
2489  struct result;
2490 
2491  template<class This, class U, class V>
2492  struct result<This(U,V)> : boost::remove_const<
2493  typename promote<
2494  typename boost::remove_const<typename boost::remove_reference<U>::type>::type,
2495  typename boost::remove_const<typename boost::remove_reference<V>::type>::type
2496  >::type> {};
2497 
2498  template<class U, class V>
2499  typename promote<
2500  typename boost::remove_const<typename boost::remove_reference<U>::type>::type,
2501  typename boost::remove_const<typename boost::remove_reference<V>::type>::type >::type
2502  operator() (const U& x, const V& y) const { return max(x,y); }
2503  };
2504 } // namespace vec_detail
2505 template<class T, class M>
2506 typename boost::proto::result_of::make_expr<
2507  boost::proto::tag::function,
2508  vec_domain,
2509  const vec_detail::max_,
2510  const int&,
2511  const vec<T,M>&
2512  >::type
2513 max (const int& x, const vec<T,M>& y)
2514 {
2515  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::max_(), boost::ref(x), boost::ref(y));
2516 }
2517 template<class T1, class T2, class M>
2518 typename boost::proto::result_of::make_expr<
2519  boost::proto::tag::function,
2520  vec_domain,
2521  const vec_detail::max_,
2522  const T1&,
2523  const vec<T2,M>&
2524  >::type
2525 max (const T1& x, const vec<T2,M>& y)
2526 {
2527  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::max_(), boost::ref(x), boost::ref(y));
2528 }
2529 template<class T, class M>
2530 typename boost::proto::result_of::make_expr<
2531  boost::proto::tag::function,
2532  vec_domain,
2533  const vec_detail::max_,
2534  const vec<T,M>&,
2535  const int&
2536  >::type
2537 max (const vec<T,M>& x, const int& y)
2538 {
2539  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::max_(), boost::ref(x), boost::ref(y));
2540 }
2541 template<class T1, class T2, class M>
2542 typename boost::proto::result_of::make_expr<
2543  boost::proto::tag::function,
2544  vec_domain,
2545  const vec_detail::max_,
2546  const vec<T1,M>&,
2547  const T2&
2548  >::type
2549 max (const vec<T1,M>& x, const T2& y)
2550 {
2551  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::max_(), boost::ref(x), boost::ref(y));
2552 }
2553 template<class T1, class T2, class M>
2554 typename boost::proto::result_of::make_expr<
2555  boost::proto::tag::function,
2556  vec_domain,
2557  const vec_detail::max_,
2558  const vec<T1,M>&,
2559  const vec<T2,M>&
2560  >::type
2561 max (const vec<T1,M>& x, const vec<T2,M>& y)
2562 {
2563  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::max_(), boost::ref(x), boost::ref(y));
2564 }
2565 template<class Expr>
2566 typename boost::proto::result_of::make_expr<
2567  boost::proto::tag::function,
2568  vec_domain,
2569  const vec_detail::max_,
2570  const int&,
2571  const vec_expr<Expr>&
2572  >::type
2573 max (const int& x, const vec_expr<Expr>& y)
2574 {
2575  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::max_(), boost::ref(x), boost::ref(y));
2576 }
2577 template<class T, class Expr>
2578 typename boost::proto::result_of::make_expr<
2579  boost::proto::tag::function,
2580  vec_domain,
2581  const vec_detail::max_,
2582  const T&,
2583  const vec_expr<Expr>&
2584  >::type
2585 max (const T& x, const vec_expr<Expr>& y)
2586 {
2587  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::max_(), boost::ref(x), boost::ref(y));
2588 }
2589 template<class Expr>
2590 typename boost::proto::result_of::make_expr<
2591  boost::proto::tag::function,
2592  vec_domain,
2593  const vec_detail::max_,
2594  const vec_expr<Expr>&,
2595  const int&
2596  >::type
2597 max (const vec_expr<Expr>& x, const int& y)
2598 {
2599  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::max_(), boost::ref(x), boost::ref(y));
2600 }
2601 template<class T, class Expr>
2602 typename boost::proto::result_of::make_expr<
2603  boost::proto::tag::function,
2604  vec_domain,
2605  const vec_detail::max_,
2606  const vec_expr<Expr>&,
2607  const T&
2608  >::type
2609 max (const vec_expr<Expr>& x, const T& y)
2610 {
2611  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::max_(), boost::ref(x), boost::ref(y));
2612 }
2613 template<class T, class M, class Expr>
2614 typename boost::proto::result_of::make_expr<
2615  boost::proto::tag::function,
2616  vec_domain,
2617  const vec_detail::max_,
2618  const vec<T,M>&,
2619  const vec_expr<Expr>&
2620  >::type
2621 max (const vec<T,M>& x, const vec_expr<Expr>& y)
2622 {
2623  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::max_(), boost::ref(x), boost::ref(y));
2624 }
2625 template<class T, class M, class Expr>
2626 typename boost::proto::result_of::make_expr<
2627  boost::proto::tag::function,
2628  vec_domain,
2629  const vec_detail::max_,
2630  const vec_expr<Expr>&,
2631  const vec<T,M>&
2632  >::type
2633 max (const vec_expr<Expr>& x, const vec<T,M>& y)
2634 {
2635  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::max_(), boost::ref(x), boost::ref(y));
2636 }
2637 template<class Expr1, class Expr2>
2638 typename boost::proto::result_of::make_expr<
2639  boost::proto::tag::function,
2640  vec_domain,
2641  const vec_detail::max_,
2642  const vec_expr<Expr1>&,
2643  const vec_expr<Expr2>&
2644  >::type
2646 {
2647  return boost::proto::make_expr<boost::proto::tag::function, vec_domain> (vec_detail::max_(), boost::ref(x), boost::ref(y));
2648 }
2649 namespace vec_detail {
2650  template<class Function>
2651  struct compose_ {
2652  compose_ (const Function& f) : _f(f) {}
2653  Function _f;
2654 
2655  template<class Sig> struct result;
2656 
2657  template<class This, class T>
2658  struct result<This(T)> : boost::remove_const<typename boost::remove_reference<T>::type> {};
2659 
2660  template<class T>
2661  T operator() (const T& x) const { return _f (x); }
2662  };
2663  template<class Arg, class Result>
2664  struct compose_<Result(Arg)> {
2665  compose_ (Result (*f)(Arg)) : _f(std::ptr_fun(f)) {}
2666  std::pointer_to_unary_function<Arg,Result> _f;
2667 
2668  template<class Sig> struct result;
2669 
2670  template<class This, class U>
2671  struct result<This(U)> : boost::remove_const<typename boost::remove_reference<Result>::type> {};
2672 
2673  Result operator() (Arg x) const { return _f (x); }
2674  };
2675 } // namespace vec_detail
2676 template<class Function, class T, class M>
2677 typename boost::proto::result_of::make_expr<
2678  boost::proto::tag::function,
2679  vec_domain,
2680  const vec_detail::compose_<Function>,
2681  const vec<T,M>&
2682  >::type
2683 compose (const Function& f, const vec<T,M>& x)
2684 {
2685  return boost::proto::make_expr<boost::proto::tag::function, vec_domain>
2686  (vec_detail::compose_<Function>(f), boost::ref(x));
2687 }
2688 template<class Function, class Expr>
2689 typename boost::proto::result_of::make_expr<
2690  boost::proto::tag::function,
2691  vec_domain,
2692  const vec_detail::compose_<Function>,
2693  const vec_expr<Expr>&
2694  >::type
2695 compose (const Function& f, const vec_expr<Expr>& x)
2696 {
2697  return boost::proto::make_expr<boost::proto::tag::function, vec_domain>
2698  (vec_detail::compose_<Function>(f), boost::ref(x));
2699 }
2700 namespace vec_detail {
2701  template<class Function>
2702  struct compose2_ {
2703  compose2_ (const Function& f) : _f(f) {}
2704  Function _f;
2705 
2706  template<class Sig> struct result;
2707 
2708  template<class This, class U, class V>
2709  struct result<This(U,V)> : boost::remove_const<
2710  typename promote<
2711  typename boost::remove_const<typename boost::remove_reference<U>::type>::type,
2712  typename boost::remove_const<typename boost::remove_reference<V>::type>::type
2713  >::type> {};
2714 
2715  template<class U, class V>
2716  typename promote<
2717  typename boost::remove_const<typename boost::remove_reference<U>::type>::type,
2718  typename boost::remove_const<typename boost::remove_reference<V>::type>::type >::type
2719  operator() (const U& x, const V& y) const { return _f (x); }
2720  };
2721  template<class Arg1, class Arg2, class Result>
2722  struct compose2_<Result(Arg1,Arg2)> {
2723  compose2_ (Result (*f)(Arg1,Arg2)) : _f(std::ptr_fun(f)) {}
2724  std::pointer_to_binary_function<Arg1,Arg2,Result> _f;
2725 
2726  template<class Sig> struct result;
2727 
2728  template<class This, class U, class V>
2729  struct result<This(U,V)> : boost::remove_const<
2730  typename promote<
2731  typename boost::remove_const<typename boost::remove_reference<U>::type>::type,
2732  typename boost::remove_const<typename boost::remove_reference<V>::type>::type
2733  >::type> {};
2734 
2735  Result operator() (Arg1 x, Arg2 y) const { return _f (x,y); }
2736  };
2737 } // namespace vec_detail
2738 template<class Function, class T, class M>
2739 typename boost::proto::result_of::make_expr<
2740  boost::proto::tag::function,
2741  vec_domain,
2742  const vec_detail::compose2_<Function>,
2743  const int&,
2744  const vec<T,M>&
2745  >::type
2746 compose (const Function& f, const int& x, const vec<T,M>& y)
2747 {
2748  return boost::proto::make_expr<boost::proto::tag::function, vec_domain>
2749  (vec_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
2750 }
2751 template<class Function, class T, class M>
2752 typename boost::proto::result_of::make_expr<
2753  boost::proto::tag::function,
2754  vec_domain,
2755  const vec_detail::compose2_<Function>,
2756  const vec<T,M>&,
2757  const int&
2758  >::type
2759 compose (const Function& f, const vec<T,M>& x, const int& y)
2760 {
2761  return boost::proto::make_expr<boost::proto::tag::function, vec_domain>
2762  (vec_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
2763 }
2764 template<class Function, class T1, class T2, class M>
2765 typename boost::proto::result_of::make_expr<
2766  boost::proto::tag::function,
2767  vec_domain,
2768  const vec_detail::compose2_<Function>,
2769  const T1&,
2770  const vec<T2,M>&
2771  >::type
2772 compose (const Function& f, const T1& x, const vec<T2,M>& y)
2773 {
2774  return boost::proto::make_expr<boost::proto::tag::function, vec_domain>
2775  (vec_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
2776 }
2777 template<class Function, class T1, class T2, class M>
2778 typename boost::proto::result_of::make_expr<
2779  boost::proto::tag::function,
2780  vec_domain,
2781  const vec_detail::compose2_<Function>,
2782  const vec<T1,M>&,
2783  const T2&
2784  >::type
2785 compose (const Function& f, const vec<T1,M>& x, const T2& y)
2786 {
2787  return boost::proto::make_expr<boost::proto::tag::function, vec_domain>
2788  (vec_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
2789 }
2790 template<class Function, class T1, class T2, class M>
2791 typename boost::proto::result_of::make_expr<
2792  boost::proto::tag::function,
2793  vec_domain,
2794  const vec_detail::compose2_<Function>,
2795  const vec<T1,M>&,
2796  const vec<T2,M>&
2797  >::type
2798 compose (const Function& f, const vec<T1,M>& x, const vec<T2,M>& y)
2799 {
2800  return boost::proto::make_expr<boost::proto::tag::function, vec_domain>
2801  (vec_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
2802 }
2803 template<class Function, class Expr>
2804 typename boost::proto::result_of::make_expr<
2805  boost::proto::tag::function,
2806  vec_domain,
2807  const vec_detail::compose2_<Function>,
2808  const int&,
2809  const vec_expr<Expr>&
2810  >::type
2811 compose (const Function& f, const int& x, const vec_expr<Expr>& y)
2812 {
2813  return boost::proto::make_expr<boost::proto::tag::function, vec_domain>
2814  (vec_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
2815 }
2816 template<class Function, class Expr>
2817 typename boost::proto::result_of::make_expr<
2818  boost::proto::tag::function,
2819  vec_domain,
2820  const vec_detail::compose2_<Function>,
2821  const vec_expr<Expr>&,
2822  const int&
2823  >::type
2824 compose (const Function& f, const vec_expr<Expr>& x, const int& y)
2825 {
2826  return boost::proto::make_expr<boost::proto::tag::function, vec_domain>
2827  (vec_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
2828 }
2829 template<class Function, class T, class Expr>
2830 typename boost::proto::result_of::make_expr<
2831  boost::proto::tag::function,
2832  vec_domain,
2833  const vec_detail::compose2_<Function>,
2834  const T&,
2835  const vec_expr<Expr>&
2836  >::type
2837 compose (const Function& f, const T& x, const vec_expr<Expr>& y)
2838 {
2839  return boost::proto::make_expr<boost::proto::tag::function, vec_domain>
2840  (vec_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
2841 }
2842 template<class Function, class T, class Expr>
2843 typename boost::proto::result_of::make_expr<
2844  boost::proto::tag::function,
2845  vec_domain,
2846  const vec_detail::compose2_<Function>,
2847  const vec_expr<Expr>&,
2848  const T&
2849  >::type
2850 compose (const Function& f, const vec_expr<Expr>& x, const T& y)
2851 {
2852  return boost::proto::make_expr<boost::proto::tag::function, vec_domain>
2853  (vec_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
2854 }
2855 template<class Function, class Expr, class T, class M>
2856 typename boost::proto::result_of::make_expr<
2857  boost::proto::tag::function,
2858  vec_domain,
2859  const vec_detail::compose2_<Function>,
2860  const vec<T,M>&,
2861  const vec_expr<Expr>&
2862  >::type
2863 compose (const Function& f, const vec<T,M>& x, const vec_expr<Expr>& y)
2864 {
2865  return boost::proto::make_expr<boost::proto::tag::function, vec_domain>
2866  (vec_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
2867 }
2868 template<class Function, class Expr, class T, class M>
2869 typename boost::proto::result_of::make_expr<
2870  boost::proto::tag::function,
2871  vec_domain,
2872  const vec_detail::compose2_<Function>,
2873  const vec_expr<Expr>&,
2874  const vec<T,M>&
2875  >::type
2876 compose (const Function& f, const vec_expr<Expr>& x, const vec<T,M>& y)
2877 {
2878  return boost::proto::make_expr<boost::proto::tag::function, vec_domain>
2879  (vec_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
2880 }
2881 template<class Function, class Expr1, class Expr2>
2882 typename boost::proto::result_of::make_expr<
2883  boost::proto::tag::function,
2884  vec_domain,
2885  const vec_detail::compose2_<Function>,
2886  const vec_expr<Expr1>&,
2887  const vec_expr<Expr2>&
2888  >::type
2889 compose (const Function& f, const vec_expr<Expr1>& x, const vec_expr<Expr2>& y)
2890 {
2891  return boost::proto::make_expr<boost::proto::tag::function, vec_domain>
2892  (vec_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
2893 }
2894 template <class T, class M>
2895 T
2896 dot (const vec<T,M>& x, const int& y)
2897 {
2898  return y*dis_accumulate (x.begin(), x.size(), x.ownership().comm());
2899 }
2900 template <class T, class M>
2901 T
2902 dot (const int& x, const vec<T,M>& y)
2903 {
2904  return x*dis_accumulate (y.begin(), y.size(), y.ownership().comm());
2905 }
2906 template <class T1, class T2, class M>
2907 typename promote<T1,T2>::type
2908 dot (const vec<T1,M>& x, const T2& y)
2909 {
2910  return y*dis_accumulate (x.begin(), x.size(), x.ownership().comm());
2911 }
2912 template <class T1, class T2, class M>
2913 typename promote<T1,T2>::type
2914 dot (const T1& x, const vec<T2,M>& y)
2915 {
2916  return x*dis_accumulate (y.begin(), y.size(), y.ownership().comm());
2917 }
2918 template <class T1, class T2, class M>
2919 typename promote<T1,T2>::type
2920 dot (const vec<T1,M>& x, const vec<T2,M>& y)
2921 {
2922  return dis_inner_product (x.begin(), y.begin(), x.size(), x.ownership().comm());
2923 }
2924 template <class Expr>
2925 typename vec_expr<Expr>::value_type
2926 dot (const vec_expr<Expr>& x, const int& y)
2927 {
2928  return y*dis_accumulate (x.begin(), x.size(), x.ownership().comm());
2929 }
2930 template <class Expr>
2931 typename vec_expr<Expr>::value_type
2932 dot (const int& x, const vec_expr<Expr>& y)
2933 {
2934  return x*dis_accumulate (y.begin(), y.size(), y.ownership().comm());
2935 }
2936 template <class T, class Expr>
2937 typename promote<T,typename vec_expr<Expr>::value_type>::type
2938 dot (const vec_expr<Expr>& x, const T& y)
2939 {
2940  return y*dis_accumulate (x.begin(), x.size(), x.ownership().comm());
2941 }
2942 template <class T, class Expr>
2943 typename promote<T,typename vec_expr<Expr>::value_type>::type
2944 dot (const T& x, const vec_expr<Expr>& y)
2945 {
2946  return x*dis_accumulate (y.begin(), y.size(), y.ownership().comm());
2947 }
2948 template <class T, class M, class Expr>
2949 typename promote<T,typename vec_expr<Expr>::value_type>::type
2950 dot (const vec<T,M>& x, const vec_expr<Expr>& y)
2951 {
2952  return dis_inner_product (x.begin(), y.begin(), x.size(), x.ownership().comm());
2953 }
2954 template <class T, class M, class Expr>
2955 typename promote<T,typename vec_expr<Expr>::value_type>::type
2956 dot (const vec_expr<Expr>& x, const vec<T,M>& y)
2957 {
2958  return dis_inner_product (x.begin(), y.begin(), x.size(), x.ownership().comm());
2959 }
2960 template <class Expr1, class Expr2>
2961 typename promote<
2962  typename vec_expr<Expr1>::value_type,
2963  typename vec_expr<Expr2>::value_type
2964 >::type
2966 {
2967  return dis_inner_product (x.begin(), y.begin(), x.size(), x.ownership().comm());
2968 }
2969 } // namespace rheolef
2970 #endif // _RHEOLEF_VEC_EXPR_OPS_H
2971