← Back to branch summary

~ubuntu-branches/ubuntu/trusty/rheolef/trusty

« back to all changes in this revision

Viewing changes to nfem/plib/field_expr_ops.h

  • Committer: Package Import Robot
  • Author(s): Pierre Saramito
  • Date: 2012-04-06 09:12:21 UTC
  • mfrom: (1.1.5)
  • Revision ID: package-import@ubuntu.com-20120406091221-m58me99p1nxqui49
Tags: 6.0-1
http://bugs.debian.org/667356
http://bugs.debian.org/661689
* New upstream release 6.0 (major changes):
  - massively distributed and parallel support
  - full FEM characteristic method (Lagrange-Gakerkin method) support
  - enhanced users documentation 
  - source code supports g++-4.7 (closes: #667356)
* debian/control: dependencies for MPI distributed solvers added
* debian/rules: build commands simplified
* debian/librheolef-dev.install: man1/* to man9/* added
* debian/changelog: package description rewritted (closes: #661689)

Show diffs side-by-side

added added

removed removed

Lines of Context:
nfem/plib/field_expr_ops.h
31
31
//
32
32
// author: Pierre.Saramito@imag.fr
33
33
//
34
 
// date: 24 feb 2011
 
34
// date: 20 march 2011
35
35
//
36
36
#include "rheolef/promote.h"
 
37
#include "rheolef/field_expr.h"
37
38
namespace rheolef {
38
39
template<class T, class M>
39
 
typename boost::proto::detail::enable_unary<
40
 
  field_domain,
41
 
  is_field<field_basic<T,M> >,
42
 
  field_basic<T,M>,
43
 
  typename boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
44
 
   ::impl<const field_basic<T,M>&>::result_type
45
 
  >::type const
46
 
operator+ (const field_basic<T,M>& arg)
47
 
{
48
 
  return boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
49
 
   ::impl<const field_basic<T,M>&>()(arg);
50
 
}
51
 
template<class T, class M>
52
 
typename boost::proto::detail::enable_unary<
53
 
  field_domain,
54
 
  is_field<field_indirect<T,M> >,
55
 
  field_indirect<T,M>,
56
 
  typename boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
57
 
   ::impl<const field_indirect<T,M>&>::result_type
58
 
  >::type const
59
 
operator+ (const field_indirect<T,M>& arg)
60
 
{
61
 
  return boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
62
 
   ::impl<const field_indirect<T,M>&>()(arg);
63
 
}
64
 
template<class T, class M>
65
 
typename boost::proto::detail::enable_unary<
66
 
  field_domain,
67
 
  is_field<field_indirect_const<T,M> >,
68
 
  field_indirect_const<T,M>,
69
 
  typename boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
70
 
   ::impl<const field_indirect_const<T,M>&>::result_type
71
 
  >::type const
72
 
operator+ (const field_indirect_const<T,M>& arg)
73
 
{
74
 
  return boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
75
 
   ::impl<const field_indirect_const<T,M>&>()(arg);
76
 
}
77
 
template<class Expr>
78
 
typename boost::proto::detail::enable_unary<
79
 
  field_domain,
80
 
  is_field<field_expr<Expr> >,
81
 
  field_expr<Expr>,
82
 
  typename boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
83
 
   ::impl<const field_expr<Expr>&>::result_type
84
 
  >::type const
85
 
operator+ (const field_expr<Expr>& arg)
86
 
{
87
 
  return boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
88
 
   ::impl<const field_expr<Expr>&>()(arg);
89
 
}
90
 
template<class T, class M>
91
 
typename boost::proto::detail::enable_unary<
92
 
  field_domain,
93
 
  is_field<field_basic<T,M> >,
94
 
  field_basic<T,M>,
95
 
  typename boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
96
 
   ::impl<const field_basic<T,M>&>::result_type
97
 
  >::type const
98
 
operator- (const field_basic<T,M>& arg)
99
 
{
100
 
  return boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
101
 
   ::impl<const field_basic<T,M>&>()(arg);
102
 
}
103
 
template<class T, class M>
104
 
typename boost::proto::detail::enable_unary<
105
 
  field_domain,
106
 
  is_field<field_indirect<T,M> >,
107
 
  field_indirect<T,M>,
108
 
  typename boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
109
 
   ::impl<const field_indirect<T,M>&>::result_type
110
 
  >::type const
111
 
operator- (const field_indirect<T,M>& arg)
112
 
{
113
 
  return boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
114
 
   ::impl<const field_indirect<T,M>&>()(arg);
115
 
}
116
 
template<class T, class M>
117
 
typename boost::proto::detail::enable_unary<
118
 
  field_domain,
119
 
  is_field<field_indirect_const<T,M> >,
120
 
  field_indirect_const<T,M>,
121
 
  typename boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
122
 
   ::impl<const field_indirect_const<T,M>&>::result_type
123
 
  >::type const
124
 
operator- (const field_indirect_const<T,M>& arg)
125
 
{
126
 
  return boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
127
 
   ::impl<const field_indirect_const<T,M>&>()(arg);
128
 
}
129
 
template<class Expr>
130
 
typename boost::proto::detail::enable_unary<
131
 
  field_domain,
132
 
  is_field<field_expr<Expr> >,
133
 
  field_expr<Expr>,
134
 
  typename boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
135
 
   ::impl<const field_expr<Expr>&>::result_type
136
 
  >::type const
137
 
operator- (const field_expr<Expr>& arg)
138
 
{
139
 
  return boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
140
 
   ::impl<const field_expr<Expr>&>()(arg);
141
 
}
142
 
template<class T, class M>
 
40
#if BOOST_VERSION < 104601
 
41
typename boost::proto::detail::enable_unary<
 
42
  field_domain,
 
43
  is_field<field_basic<T,M> >,
 
44
  field_basic<T,M>,
 
45
  typename boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
 
46
   ::impl<const field_basic<T,M>&>::result_type
 
47
  >::type const
 
48
operator+ (const field_basic<T,M>& arg)
 
49
{
 
50
  return boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
 
51
   ::impl<const field_basic<T,M>&>()(arg);
 
52
}
 
53
#else // BOOST_VERSION >= 104601
 
54
typename boost::proto::detail::enable_unary<
 
55
  field_domain,
 
56
  field_domain::proto_grammar,
 
57
  boost::mpl::and_<
 
58
    is_field<field_basic<T,M> >,
 
59
    boost::mpl::not_<boost::proto::is_extension<field_basic<T,M> > >
 
60
  >,
 
61
  boost::proto::tag::unary_plus,
 
62
  field_basic<T,M> const &
 
63
>::type const
 
64
operator+ (const field_basic<T,M>& arg)
 
65
{
 
66
  return boost::proto::detail::make_expr_<boost::proto::tag::unary_plus, field_domain, field_basic<T,M> 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
  field_domain,
 
73
  is_field<field_indirect<T,M> >,
 
74
  field_indirect<T,M>,
 
75
  typename boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
 
76
   ::impl<const field_indirect<T,M>&>::result_type
 
77
  >::type const
 
78
operator+ (const field_indirect<T,M>& arg)
 
79
{
 
80
  return boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
 
81
   ::impl<const field_indirect<T,M>&>()(arg);
 
82
}
 
83
#else // BOOST_VERSION >= 104601
 
84
typename boost::proto::detail::enable_unary<
 
85
  field_domain,
 
86
  field_domain::proto_grammar,
 
87
  boost::mpl::and_<
 
88
    is_field<field_indirect<T,M> >,
 
89
    boost::mpl::not_<boost::proto::is_extension<field_indirect<T,M> > >
 
90
  >,
 
91
  boost::proto::tag::unary_plus,
 
92
  field_indirect<T,M> const &
 
93
>::type const
 
94
operator+ (const field_indirect<T,M>& arg)
 
95
{
 
96
  return boost::proto::detail::make_expr_<boost::proto::tag::unary_plus, field_domain, field_indirect<T,M> const &>()(arg);
 
97
}
 
98
#endif // BOOST_VERSION
 
99
template<class T, class M>
 
100
#if BOOST_VERSION < 104601
 
101
typename boost::proto::detail::enable_unary<
 
102
  field_domain,
 
103
  is_field<field_indirect_const<T,M> >,
 
104
  field_indirect_const<T,M>,
 
105
  typename boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
 
106
   ::impl<const field_indirect_const<T,M>&>::result_type
 
107
  >::type const
 
108
operator+ (const field_indirect_const<T,M>& arg)
 
109
{
 
110
  return boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
 
111
   ::impl<const field_indirect_const<T,M>&>()(arg);
 
112
}
 
113
#else // BOOST_VERSION >= 104601
 
114
typename boost::proto::detail::enable_unary<
 
115
  field_domain,
 
116
  field_domain::proto_grammar,
 
117
  boost::mpl::and_<
 
118
    is_field<field_indirect_const<T,M> >,
 
119
    boost::mpl::not_<boost::proto::is_extension<field_indirect_const<T,M> > >
 
120
  >,
 
121
  boost::proto::tag::unary_plus,
 
122
  field_indirect_const<T,M> const &
 
123
>::type const
 
124
operator+ (const field_indirect_const<T,M>& arg)
 
125
{
 
126
  return boost::proto::detail::make_expr_<boost::proto::tag::unary_plus, field_domain, field_indirect_const<T,M> const &>()(arg);
 
127
}
 
128
#endif // BOOST_VERSION
 
129
template<class T, class M>
 
130
#if BOOST_VERSION < 104601
 
131
typename boost::proto::detail::enable_unary<
 
132
  field_domain,
 
133
  is_field<field_component<T,M> >,
 
134
  field_component<T,M>,
 
135
  typename boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
 
136
   ::impl<const field_component<T,M>&>::result_type
 
137
  >::type const
 
138
operator+ (const field_component<T,M>& arg)
 
139
{
 
140
  return boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
 
141
   ::impl<const field_component<T,M>&>()(arg);
 
142
}
 
143
#else // BOOST_VERSION >= 104601
 
144
typename boost::proto::detail::enable_unary<
 
145
  field_domain,
 
146
  field_domain::proto_grammar,
 
147
  boost::mpl::and_<
 
148
    is_field<field_component<T,M> >,
 
149
    boost::mpl::not_<boost::proto::is_extension<field_component<T,M> > >
 
150
  >,
 
151
  boost::proto::tag::unary_plus,
 
152
  field_component<T,M> const &
 
153
>::type const
 
154
operator+ (const field_component<T,M>& arg)
 
155
{
 
156
  return boost::proto::detail::make_expr_<boost::proto::tag::unary_plus, field_domain, field_component<T,M> const &>()(arg);
 
157
}
 
158
#endif // BOOST_VERSION
 
159
template<class T, class M>
 
160
#if BOOST_VERSION < 104601
 
161
typename boost::proto::detail::enable_unary<
 
162
  field_domain,
 
163
  is_field<field_component_const<T,M> >,
 
164
  field_component_const<T,M>,
 
165
  typename boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
 
166
   ::impl<const field_component_const<T,M>&>::result_type
 
167
  >::type const
 
168
operator+ (const field_component_const<T,M>& arg)
 
169
{
 
170
  return boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
 
171
   ::impl<const field_component_const<T,M>&>()(arg);
 
172
}
 
173
#else // BOOST_VERSION >= 104601
 
174
typename boost::proto::detail::enable_unary<
 
175
  field_domain,
 
176
  field_domain::proto_grammar,
 
177
  boost::mpl::and_<
 
178
    is_field<field_component_const<T,M> >,
 
179
    boost::mpl::not_<boost::proto::is_extension<field_component_const<T,M> > >
 
180
  >,
 
181
  boost::proto::tag::unary_plus,
 
182
  field_component_const<T,M> const &
 
183
>::type const
 
184
operator+ (const field_component_const<T,M>& arg)
 
185
{
 
186
  return boost::proto::detail::make_expr_<boost::proto::tag::unary_plus, field_domain, field_component_const<T,M> const &>()(arg);
 
187
}
 
188
#endif // BOOST_VERSION
 
189
template<class Expr>
 
190
#if BOOST_VERSION < 104601
 
191
typename boost::proto::detail::enable_unary<
 
192
  field_domain,
 
193
  is_field<field_expr<Expr> >,
 
194
  field_expr<Expr>,
 
195
  typename boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
 
196
   ::impl<const field_expr<Expr>&>::result_type
 
197
  >::type const
 
198
operator+ (const field_expr<Expr>& arg)
 
199
{
 
200
  return boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
 
201
   ::impl<const field_expr<Expr>&>()(arg);
 
202
}
 
203
#else // BOOST_VERSION >= 104601
 
204
typename boost::proto::detail::enable_unary<
 
205
  field_domain,
 
206
  field_domain::proto_grammar,
 
207
  boost::mpl::and_<
 
208
    is_field<field_expr<Expr> >,
 
209
    boost::mpl::not_<boost::proto::is_extension<field_expr<Expr> > >
 
210
  >,
 
211
  boost::proto::tag::unary_plus,
 
212
  field_expr<Expr> const &
 
213
>::type const
 
214
operator+ (const field_expr<Expr>& arg)
 
215
{
 
216
  return boost::proto::detail::make_expr_<boost::proto::tag::unary_plus, field_domain, field_expr<Expr> const &>()(arg);
 
217
}
 
218
#endif // BOOST_VERSION
 
219
template<class T, class M>
 
220
#if BOOST_VERSION < 104601
 
221
typename boost::proto::detail::enable_unary<
 
222
  field_domain,
 
223
  is_field<field_basic<T,M> >,
 
224
  field_basic<T,M>,
 
225
  typename boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
 
226
   ::impl<const field_basic<T,M>&>::result_type
 
227
  >::type const
 
228
operator- (const field_basic<T,M>& arg)
 
229
{
 
230
  return boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
 
231
   ::impl<const field_basic<T,M>&>()(arg);
 
232
}
 
233
#else // BOOST_VERSION >= 104601
 
234
typename boost::proto::detail::enable_unary<
 
235
  field_domain,
 
236
  field_domain::proto_grammar,
 
237
  boost::mpl::and_<
 
238
    is_field<field_basic<T,M> >,
 
239
    boost::mpl::not_<boost::proto::is_extension<field_basic<T,M> > >
 
240
  >,
 
241
  boost::proto::tag::negate,
 
242
  field_basic<T,M> const &
 
243
>::type const
 
244
operator- (const field_basic<T,M>& arg)
 
245
{
 
246
  return boost::proto::detail::make_expr_<boost::proto::tag::negate, field_domain, field_basic<T,M> const &>()(arg);
 
247
}
 
248
#endif // BOOST_VERSION
 
249
template<class T, class M>
 
250
#if BOOST_VERSION < 104601
 
251
typename boost::proto::detail::enable_unary<
 
252
  field_domain,
 
253
  is_field<field_indirect<T,M> >,
 
254
  field_indirect<T,M>,
 
255
  typename boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
 
256
   ::impl<const field_indirect<T,M>&>::result_type
 
257
  >::type const
 
258
operator- (const field_indirect<T,M>& arg)
 
259
{
 
260
  return boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
 
261
   ::impl<const field_indirect<T,M>&>()(arg);
 
262
}
 
263
#else // BOOST_VERSION >= 104601
 
264
typename boost::proto::detail::enable_unary<
 
265
  field_domain,
 
266
  field_domain::proto_grammar,
 
267
  boost::mpl::and_<
 
268
    is_field<field_indirect<T,M> >,
 
269
    boost::mpl::not_<boost::proto::is_extension<field_indirect<T,M> > >
 
270
  >,
 
271
  boost::proto::tag::negate,
 
272
  field_indirect<T,M> const &
 
273
>::type const
 
274
operator- (const field_indirect<T,M>& arg)
 
275
{
 
276
  return boost::proto::detail::make_expr_<boost::proto::tag::negate, field_domain, field_indirect<T,M> const &>()(arg);
 
277
}
 
278
#endif // BOOST_VERSION
 
279
template<class T, class M>
 
280
#if BOOST_VERSION < 104601
 
281
typename boost::proto::detail::enable_unary<
 
282
  field_domain,
 
283
  is_field<field_indirect_const<T,M> >,
 
284
  field_indirect_const<T,M>,
 
285
  typename boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
 
286
   ::impl<const field_indirect_const<T,M>&>::result_type
 
287
  >::type const
 
288
operator- (const field_indirect_const<T,M>& arg)
 
289
{
 
290
  return boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
 
291
   ::impl<const field_indirect_const<T,M>&>()(arg);
 
292
}
 
293
#else // BOOST_VERSION >= 104601
 
294
typename boost::proto::detail::enable_unary<
 
295
  field_domain,
 
296
  field_domain::proto_grammar,
 
297
  boost::mpl::and_<
 
298
    is_field<field_indirect_const<T,M> >,
 
299
    boost::mpl::not_<boost::proto::is_extension<field_indirect_const<T,M> > >
 
300
  >,
 
301
  boost::proto::tag::negate,
 
302
  field_indirect_const<T,M> const &
 
303
>::type const
 
304
operator- (const field_indirect_const<T,M>& arg)
 
305
{
 
306
  return boost::proto::detail::make_expr_<boost::proto::tag::negate, field_domain, field_indirect_const<T,M> const &>()(arg);
 
307
}
 
308
#endif // BOOST_VERSION
 
309
template<class T, class M>
 
310
#if BOOST_VERSION < 104601
 
311
typename boost::proto::detail::enable_unary<
 
312
  field_domain,
 
313
  is_field<field_component<T,M> >,
 
314
  field_component<T,M>,
 
315
  typename boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
 
316
   ::impl<const field_component<T,M>&>::result_type
 
317
  >::type const
 
318
operator- (const field_component<T,M>& arg)
 
319
{
 
320
  return boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
 
321
   ::impl<const field_component<T,M>&>()(arg);
 
322
}
 
323
#else // BOOST_VERSION >= 104601
 
324
typename boost::proto::detail::enable_unary<
 
325
  field_domain,
 
326
  field_domain::proto_grammar,
 
327
  boost::mpl::and_<
 
328
    is_field<field_component<T,M> >,
 
329
    boost::mpl::not_<boost::proto::is_extension<field_component<T,M> > >
 
330
  >,
 
331
  boost::proto::tag::negate,
 
332
  field_component<T,M> const &
 
333
>::type const
 
334
operator- (const field_component<T,M>& arg)
 
335
{
 
336
  return boost::proto::detail::make_expr_<boost::proto::tag::negate, field_domain, field_component<T,M> const &>()(arg);
 
337
}
 
338
#endif // BOOST_VERSION
 
339
template<class T, class M>
 
340
#if BOOST_VERSION < 104601
 
341
typename boost::proto::detail::enable_unary<
 
342
  field_domain,
 
343
  is_field<field_component_const<T,M> >,
 
344
  field_component_const<T,M>,
 
345
  typename boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
 
346
   ::impl<const field_component_const<T,M>&>::result_type
 
347
  >::type const
 
348
operator- (const field_component_const<T,M>& arg)
 
349
{
 
350
  return boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
 
351
   ::impl<const field_component_const<T,M>&>()(arg);
 
352
}
 
353
#else // BOOST_VERSION >= 104601
 
354
typename boost::proto::detail::enable_unary<
 
355
  field_domain,
 
356
  field_domain::proto_grammar,
 
357
  boost::mpl::and_<
 
358
    is_field<field_component_const<T,M> >,
 
359
    boost::mpl::not_<boost::proto::is_extension<field_component_const<T,M> > >
 
360
  >,
 
361
  boost::proto::tag::negate,
 
362
  field_component_const<T,M> const &
 
363
>::type const
 
364
operator- (const field_component_const<T,M>& arg)
 
365
{
 
366
  return boost::proto::detail::make_expr_<boost::proto::tag::negate, field_domain, field_component_const<T,M> const &>()(arg);
 
367
}
 
368
#endif // BOOST_VERSION
 
369
template<class Expr>
 
370
#if BOOST_VERSION < 104601
 
371
typename boost::proto::detail::enable_unary<
 
372
  field_domain,
 
373
  is_field<field_expr<Expr> >,
 
374
  field_expr<Expr>,
 
375
  typename boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
 
376
   ::impl<const field_expr<Expr>&>::result_type
 
377
  >::type const
 
378
operator- (const field_expr<Expr>& arg)
 
379
{
 
380
  return boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
 
381
   ::impl<const field_expr<Expr>&>()(arg);
 
382
}
 
383
#else // BOOST_VERSION >= 104601
 
384
typename boost::proto::detail::enable_unary<
 
385
  field_domain,
 
386
  field_domain::proto_grammar,
 
387
  boost::mpl::and_<
 
388
    is_field<field_expr<Expr> >,
 
389
    boost::mpl::not_<boost::proto::is_extension<field_expr<Expr> > >
 
390
  >,
 
391
  boost::proto::tag::negate,
 
392
  field_expr<Expr> const &
 
393
>::type const
 
394
operator- (const field_expr<Expr>& arg)
 
395
{
 
396
  return boost::proto::detail::make_expr_<boost::proto::tag::negate, field_domain, field_expr<Expr> const &>()(arg);
 
397
}
 
398
#endif // BOOST_VERSION
 
399
template<class T, class M>
 
400
#if BOOST_VERSION < 104601
143
401
typename
144
402
boost::proto::detail::enable_binary<
145
403
  field_domain,
153
411
operator+ (const int& l, const field_basic<T,M>& r)
154
412
{
155
413
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
156
 
    ::impl<const int&,   const field_basic<T,M>&>() (l, r);
157
 
}
 
414
    ::impl<const int&, const field_basic<T,M>&>() (l, r);
 
415
}
 
416
#else // BOOST_VERSION >= 104601
 
417
typename boost::proto::detail::enable_binary< 
 
418
  field_domain,
 
419
  field_domain::proto_grammar,
 
420
  boost::mpl::and_<
 
421
    boost::mpl::or_<is_field<int >, is_field<field_basic<T,M> > >,
 
422
    boost::mpl::not_<
 
423
      boost::mpl::or_<
 
424
        boost::proto::is_extension<int >,
 
425
        boost::proto::is_extension<field_basic<T,M> >
 
426
      >
 
427
    >
 
428
  >,
 
429
  boost::proto::tag::plus,
 
430
  int const &,
 
431
  field_basic<T,M> const &
 
432
>::type /* const */
 
433
operator+ (int const &left, field_basic<T,M> const &right)
 
434
{
 
435
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, int const &, field_basic<T,M> const &>()(left, right);
 
436
}
 
437
#endif // BOOST_VERSION
158
438
template<class T, class M>
 
439
#if BOOST_VERSION < 104601
159
440
typename
160
441
boost::proto::detail::enable_binary<
161
442
  field_domain,
169
450
operator+ (const T& l, const field_basic<T,M>& r)
170
451
{
171
452
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
172
 
    ::impl<const T&,   const field_basic<T,M>&>() (l, r);
173
 
}
 
453
    ::impl<const T&, const field_basic<T,M>&>() (l, r);
 
454
}
 
455
#else // BOOST_VERSION >= 104601
 
456
typename boost::proto::detail::enable_binary< 
 
457
  field_domain,
 
458
  field_domain::proto_grammar,
 
459
  boost::mpl::and_<
 
460
    boost::mpl::or_<is_field<T >, is_field<field_basic<T,M> > >,
 
461
    boost::mpl::not_<
 
462
      boost::mpl::or_<
 
463
        boost::proto::is_extension<T >,
 
464
        boost::proto::is_extension<field_basic<T,M> >
 
465
      >
 
466
    >
 
467
  >,
 
468
  boost::proto::tag::plus,
 
469
  T const &,
 
470
  field_basic<T,M> const &
 
471
>::type /* const */
 
472
operator+ (T const &left, field_basic<T,M> const &right)
 
473
{
 
474
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, T const &, field_basic<T,M> const &>()(left, right);
 
475
}
 
476
#endif // BOOST_VERSION
174
477
template<class T, class M>
 
478
#if BOOST_VERSION < 104601
175
479
typename
176
480
boost::proto::detail::enable_binary<
177
481
  field_domain,
185
489
operator+ (const int& l, const field_indirect<T,M>& r)
186
490
{
187
491
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
188
 
    ::impl<const int&,   const field_indirect<T,M>&>() (l, r);
189
 
}
 
492
    ::impl<const int&, const field_indirect<T,M>&>() (l, r);
 
493
}
 
494
#else // BOOST_VERSION >= 104601
 
495
typename boost::proto::detail::enable_binary< 
 
496
  field_domain,
 
497
  field_domain::proto_grammar,
 
498
  boost::mpl::and_<
 
499
    boost::mpl::or_<is_field<int >, is_field<field_indirect<T,M> > >,
 
500
    boost::mpl::not_<
 
501
      boost::mpl::or_<
 
502
        boost::proto::is_extension<int >,
 
503
        boost::proto::is_extension<field_indirect<T,M> >
 
504
      >
 
505
    >
 
506
  >,
 
507
  boost::proto::tag::plus,
 
508
  int const &,
 
509
  field_indirect<T,M> const &
 
510
>::type /* const */
 
511
operator+ (int const &left, field_indirect<T,M> const &right)
 
512
{
 
513
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, int const &, field_indirect<T,M> const &>()(left, right);
 
514
}
 
515
#endif // BOOST_VERSION
190
516
template<class T, class M>
 
517
#if BOOST_VERSION < 104601
191
518
typename
192
519
boost::proto::detail::enable_binary<
193
520
  field_domain,
201
528
operator+ (const T& l, const field_indirect<T,M>& r)
202
529
{
203
530
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
204
 
    ::impl<const T&,   const field_indirect<T,M>&>() (l, r);
205
 
}
 
531
    ::impl<const T&, const field_indirect<T,M>&>() (l, r);
 
532
}
 
533
#else // BOOST_VERSION >= 104601
 
534
typename boost::proto::detail::enable_binary< 
 
535
  field_domain,
 
536
  field_domain::proto_grammar,
 
537
  boost::mpl::and_<
 
538
    boost::mpl::or_<is_field<T >, is_field<field_indirect<T,M> > >,
 
539
    boost::mpl::not_<
 
540
      boost::mpl::or_<
 
541
        boost::proto::is_extension<T >,
 
542
        boost::proto::is_extension<field_indirect<T,M> >
 
543
      >
 
544
    >
 
545
  >,
 
546
  boost::proto::tag::plus,
 
547
  T const &,
 
548
  field_indirect<T,M> const &
 
549
>::type /* const */
 
550
operator+ (T const &left, field_indirect<T,M> const &right)
 
551
{
 
552
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, T const &, field_indirect<T,M> const &>()(left, right);
 
553
}
 
554
#endif // BOOST_VERSION
206
555
template<class T, class M>
 
556
#if BOOST_VERSION < 104601
207
557
typename
208
558
boost::proto::detail::enable_binary<
209
559
  field_domain,
217
567
operator+ (const int& l, const field_indirect_const<T,M>& r)
218
568
{
219
569
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
220
 
    ::impl<const int&,   const field_indirect_const<T,M>&>() (l, r);
221
 
}
 
570
    ::impl<const int&, const field_indirect_const<T,M>&>() (l, r);
 
571
}
 
572
#else // BOOST_VERSION >= 104601
 
573
typename boost::proto::detail::enable_binary< 
 
574
  field_domain,
 
575
  field_domain::proto_grammar,
 
576
  boost::mpl::and_<
 
577
    boost::mpl::or_<is_field<int >, is_field<field_indirect_const<T,M> > >,
 
578
    boost::mpl::not_<
 
579
      boost::mpl::or_<
 
580
        boost::proto::is_extension<int >,
 
581
        boost::proto::is_extension<field_indirect_const<T,M> >
 
582
      >
 
583
    >
 
584
  >,
 
585
  boost::proto::tag::plus,
 
586
  int const &,
 
587
  field_indirect_const<T,M> const &
 
588
>::type /* const */
 
589
operator+ (int const &left, field_indirect_const<T,M> const &right)
 
590
{
 
591
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, int const &, field_indirect_const<T,M> const &>()(left, right);
 
592
}
 
593
#endif // BOOST_VERSION
222
594
template<class T, class M>
 
595
#if BOOST_VERSION < 104601
223
596
typename
224
597
boost::proto::detail::enable_binary<
225
598
  field_domain,
233
606
operator+ (const T& l, const field_indirect_const<T,M>& r)
234
607
{
235
608
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
236
 
    ::impl<const T&,   const field_indirect_const<T,M>&>() (l, r);
237
 
}
238
 
template<class T, class M>
 
609
    ::impl<const T&, const field_indirect_const<T,M>&>() (l, r);
 
610
}
 
611
#else // BOOST_VERSION >= 104601
 
612
typename boost::proto::detail::enable_binary< 
 
613
  field_domain,
 
614
  field_domain::proto_grammar,
 
615
  boost::mpl::and_<
 
616
    boost::mpl::or_<is_field<T >, is_field<field_indirect_const<T,M> > >,
 
617
    boost::mpl::not_<
 
618
      boost::mpl::or_<
 
619
        boost::proto::is_extension<T >,
 
620
        boost::proto::is_extension<field_indirect_const<T,M> >
 
621
      >
 
622
    >
 
623
  >,
 
624
  boost::proto::tag::plus,
 
625
  T const &,
 
626
  field_indirect_const<T,M> const &
 
627
>::type /* const */
 
628
operator+ (T const &left, field_indirect_const<T,M> const &right)
 
629
{
 
630
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, T const &, field_indirect_const<T,M> const &>()(left, right);
 
631
}
 
632
#endif // BOOST_VERSION
 
633
template<class T, class M>
 
634
#if BOOST_VERSION < 104601
 
635
typename
 
636
boost::proto::detail::enable_binary<
 
637
  field_domain,
 
638
  is_field<int >,
 
639
  int,
 
640
  is_field<field_component<T,M> >,
 
641
  field_component<T,M>,
 
642
  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
643
    ::impl<const int&,   const field_component<T,M>&>::result_type const
 
644
>::type
 
645
operator+ (const int& l, const field_component<T,M>& r)
 
646
{
 
647
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
648
    ::impl<const int&, const field_component<T,M>&>() (l, r);
 
649
}
 
650
#else // BOOST_VERSION >= 104601
 
651
typename boost::proto::detail::enable_binary< 
 
652
  field_domain,
 
653
  field_domain::proto_grammar,
 
654
  boost::mpl::and_<
 
655
    boost::mpl::or_<is_field<int >, is_field<field_component<T,M> > >,
 
656
    boost::mpl::not_<
 
657
      boost::mpl::or_<
 
658
        boost::proto::is_extension<int >,
 
659
        boost::proto::is_extension<field_component<T,M> >
 
660
      >
 
661
    >
 
662
  >,
 
663
  boost::proto::tag::plus,
 
664
  int const &,
 
665
  field_component<T,M> const &
 
666
>::type /* const */
 
667
operator+ (int const &left, field_component<T,M> const &right)
 
668
{
 
669
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, int const &, field_component<T,M> const &>()(left, right);
 
670
}
 
671
#endif // BOOST_VERSION
 
672
template<class T, class M>
 
673
#if BOOST_VERSION < 104601
 
674
typename
 
675
boost::proto::detail::enable_binary<
 
676
  field_domain,
 
677
  is_field<T >,
 
678
  T,
 
679
  is_field<field_component<T,M> >,
 
680
  field_component<T,M>,
 
681
  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
682
    ::impl<const T&,   const field_component<T,M>&>::result_type const
 
683
>::type
 
684
operator+ (const T& l, const field_component<T,M>& r)
 
685
{
 
686
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
687
    ::impl<const T&, const field_component<T,M>&>() (l, r);
 
688
}
 
689
#else // BOOST_VERSION >= 104601
 
690
typename boost::proto::detail::enable_binary< 
 
691
  field_domain,
 
692
  field_domain::proto_grammar,
 
693
  boost::mpl::and_<
 
694
    boost::mpl::or_<is_field<T >, is_field<field_component<T,M> > >,
 
695
    boost::mpl::not_<
 
696
      boost::mpl::or_<
 
697
        boost::proto::is_extension<T >,
 
698
        boost::proto::is_extension<field_component<T,M> >
 
699
      >
 
700
    >
 
701
  >,
 
702
  boost::proto::tag::plus,
 
703
  T const &,
 
704
  field_component<T,M> const &
 
705
>::type /* const */
 
706
operator+ (T const &left, field_component<T,M> const &right)
 
707
{
 
708
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, T const &, field_component<T,M> const &>()(left, right);
 
709
}
 
710
#endif // BOOST_VERSION
 
711
template<class T, class M>
 
712
#if BOOST_VERSION < 104601
 
713
typename
 
714
boost::proto::detail::enable_binary<
 
715
  field_domain,
 
716
  is_field<int >,
 
717
  int,
 
718
  is_field<field_component_const<T,M> >,
 
719
  field_component_const<T,M>,
 
720
  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
721
    ::impl<const int&,   const field_component_const<T,M>&>::result_type const
 
722
>::type
 
723
operator+ (const int& l, const field_component_const<T,M>& r)
 
724
{
 
725
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
726
    ::impl<const int&, const field_component_const<T,M>&>() (l, r);
 
727
}
 
728
#else // BOOST_VERSION >= 104601
 
729
typename boost::proto::detail::enable_binary< 
 
730
  field_domain,
 
731
  field_domain::proto_grammar,
 
732
  boost::mpl::and_<
 
733
    boost::mpl::or_<is_field<int >, is_field<field_component_const<T,M> > >,
 
734
    boost::mpl::not_<
 
735
      boost::mpl::or_<
 
736
        boost::proto::is_extension<int >,
 
737
        boost::proto::is_extension<field_component_const<T,M> >
 
738
      >
 
739
    >
 
740
  >,
 
741
  boost::proto::tag::plus,
 
742
  int const &,
 
743
  field_component_const<T,M> const &
 
744
>::type /* const */
 
745
operator+ (int const &left, field_component_const<T,M> const &right)
 
746
{
 
747
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, int const &, field_component_const<T,M> const &>()(left, right);
 
748
}
 
749
#endif // BOOST_VERSION
 
750
template<class T, class M>
 
751
#if BOOST_VERSION < 104601
 
752
typename
 
753
boost::proto::detail::enable_binary<
 
754
  field_domain,
 
755
  is_field<T >,
 
756
  T,
 
757
  is_field<field_component_const<T,M> >,
 
758
  field_component_const<T,M>,
 
759
  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
760
    ::impl<const T&,   const field_component_const<T,M>&>::result_type const
 
761
>::type
 
762
operator+ (const T& l, const field_component_const<T,M>& r)
 
763
{
 
764
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
765
    ::impl<const T&, const field_component_const<T,M>&>() (l, r);
 
766
}
 
767
#else // BOOST_VERSION >= 104601
 
768
typename boost::proto::detail::enable_binary< 
 
769
  field_domain,
 
770
  field_domain::proto_grammar,
 
771
  boost::mpl::and_<
 
772
    boost::mpl::or_<is_field<T >, is_field<field_component_const<T,M> > >,
 
773
    boost::mpl::not_<
 
774
      boost::mpl::or_<
 
775
        boost::proto::is_extension<T >,
 
776
        boost::proto::is_extension<field_component_const<T,M> >
 
777
      >
 
778
    >
 
779
  >,
 
780
  boost::proto::tag::plus,
 
781
  T const &,
 
782
  field_component_const<T,M> const &
 
783
>::type /* const */
 
784
operator+ (T const &left, field_component_const<T,M> const &right)
 
785
{
 
786
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, T const &, field_component_const<T,M> const &>()(left, right);
 
787
}
 
788
#endif // BOOST_VERSION
 
789
template<class T, class M>
 
790
#if BOOST_VERSION < 104601
239
791
typename
240
792
boost::proto::detail::enable_binary<
241
793
  field_domain,
249
801
operator+ (const field_basic<T,M>& l, const int& r)
250
802
{
251
803
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
252
 
    ::impl<const field_basic<T,M>&,   const int&>() (l, r);
253
 
}
 
804
    ::impl<const field_basic<T,M>&, const int&>() (l, r);
 
805
}
 
806
#else // BOOST_VERSION >= 104601
 
807
typename boost::proto::detail::enable_binary< 
 
808
  field_domain,
 
809
  field_domain::proto_grammar,
 
810
  boost::mpl::and_<
 
811
    boost::mpl::or_<is_field<field_basic<T,M> >, is_field<int > >,
 
812
    boost::mpl::not_<
 
813
      boost::mpl::or_<
 
814
        boost::proto::is_extension<field_basic<T,M> >,
 
815
        boost::proto::is_extension<int >
 
816
      >
 
817
    >
 
818
  >,
 
819
  boost::proto::tag::plus,
 
820
  field_basic<T,M> const &,
 
821
  int const &
 
822
>::type /* const */
 
823
operator+ (field_basic<T,M> const &left, int const &right)
 
824
{
 
825
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_basic<T,M> const &, int const &>()(left, right);
 
826
}
 
827
#endif // BOOST_VERSION
254
828
template<class T, class M>
 
829
#if BOOST_VERSION < 104601
255
830
typename
256
831
boost::proto::detail::enable_binary<
257
832
  field_domain,
265
840
operator+ (const field_basic<T,M>& l, const T& r)
266
841
{
267
842
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
268
 
    ::impl<const field_basic<T,M>&,   const T&>() (l, r);
269
 
}
 
843
    ::impl<const field_basic<T,M>&, const T&>() (l, r);
 
844
}
 
845
#else // BOOST_VERSION >= 104601
 
846
typename boost::proto::detail::enable_binary< 
 
847
  field_domain,
 
848
  field_domain::proto_grammar,
 
849
  boost::mpl::and_<
 
850
    boost::mpl::or_<is_field<field_basic<T,M> >, is_field<T > >,
 
851
    boost::mpl::not_<
 
852
      boost::mpl::or_<
 
853
        boost::proto::is_extension<field_basic<T,M> >,
 
854
        boost::proto::is_extension<T >
 
855
      >
 
856
    >
 
857
  >,
 
858
  boost::proto::tag::plus,
 
859
  field_basic<T,M> const &,
 
860
  T const &
 
861
>::type /* const */
 
862
operator+ (field_basic<T,M> const &left, T const &right)
 
863
{
 
864
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_basic<T,M> const &, T const &>()(left, right);
 
865
}
 
866
#endif // BOOST_VERSION
270
867
template<class T, class M>
 
868
#if BOOST_VERSION < 104601
271
869
typename
272
870
boost::proto::detail::enable_binary<
273
871
  field_domain,
281
879
operator+ (const field_indirect<T,M>& l, const int& r)
282
880
{
283
881
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
284
 
    ::impl<const field_indirect<T,M>&,   const int&>() (l, r);
285
 
}
 
882
    ::impl<const field_indirect<T,M>&, const int&>() (l, r);
 
883
}
 
884
#else // BOOST_VERSION >= 104601
 
885
typename boost::proto::detail::enable_binary< 
 
886
  field_domain,
 
887
  field_domain::proto_grammar,
 
888
  boost::mpl::and_<
 
889
    boost::mpl::or_<is_field<field_indirect<T,M> >, is_field<int > >,
 
890
    boost::mpl::not_<
 
891
      boost::mpl::or_<
 
892
        boost::proto::is_extension<field_indirect<T,M> >,
 
893
        boost::proto::is_extension<int >
 
894
      >
 
895
    >
 
896
  >,
 
897
  boost::proto::tag::plus,
 
898
  field_indirect<T,M> const &,
 
899
  int const &
 
900
>::type /* const */
 
901
operator+ (field_indirect<T,M> const &left, int const &right)
 
902
{
 
903
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect<T,M> const &, int const &>()(left, right);
 
904
}
 
905
#endif // BOOST_VERSION
286
906
template<class T, class M>
 
907
#if BOOST_VERSION < 104601
287
908
typename
288
909
boost::proto::detail::enable_binary<
289
910
  field_domain,
297
918
operator+ (const field_indirect<T,M>& l, const T& r)
298
919
{
299
920
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
300
 
    ::impl<const field_indirect<T,M>&,   const T&>() (l, r);
301
 
}
 
921
    ::impl<const field_indirect<T,M>&, const T&>() (l, r);
 
922
}
 
923
#else // BOOST_VERSION >= 104601
 
924
typename boost::proto::detail::enable_binary< 
 
925
  field_domain,
 
926
  field_domain::proto_grammar,
 
927
  boost::mpl::and_<
 
928
    boost::mpl::or_<is_field<field_indirect<T,M> >, is_field<T > >,
 
929
    boost::mpl::not_<
 
930
      boost::mpl::or_<
 
931
        boost::proto::is_extension<field_indirect<T,M> >,
 
932
        boost::proto::is_extension<T >
 
933
      >
 
934
    >
 
935
  >,
 
936
  boost::proto::tag::plus,
 
937
  field_indirect<T,M> const &,
 
938
  T const &
 
939
>::type /* const */
 
940
operator+ (field_indirect<T,M> const &left, T const &right)
 
941
{
 
942
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect<T,M> const &, T const &>()(left, right);
 
943
}
 
944
#endif // BOOST_VERSION
302
945
template<class T, class M>
 
946
#if BOOST_VERSION < 104601
303
947
typename
304
948
boost::proto::detail::enable_binary<
305
949
  field_domain,
313
957
operator+ (const field_indirect_const<T,M>& l, const int& r)
314
958
{
315
959
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
316
 
    ::impl<const field_indirect_const<T,M>&,   const int&>() (l, r);
317
 
}
 
960
    ::impl<const field_indirect_const<T,M>&, const int&>() (l, r);
 
961
}
 
962
#else // BOOST_VERSION >= 104601
 
963
typename boost::proto::detail::enable_binary< 
 
964
  field_domain,
 
965
  field_domain::proto_grammar,
 
966
  boost::mpl::and_<
 
967
    boost::mpl::or_<is_field<field_indirect_const<T,M> >, is_field<int > >,
 
968
    boost::mpl::not_<
 
969
      boost::mpl::or_<
 
970
        boost::proto::is_extension<field_indirect_const<T,M> >,
 
971
        boost::proto::is_extension<int >
 
972
      >
 
973
    >
 
974
  >,
 
975
  boost::proto::tag::plus,
 
976
  field_indirect_const<T,M> const &,
 
977
  int const &
 
978
>::type /* const */
 
979
operator+ (field_indirect_const<T,M> const &left, int const &right)
 
980
{
 
981
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect_const<T,M> const &, int const &>()(left, right);
 
982
}
 
983
#endif // BOOST_VERSION
318
984
template<class T, class M>
 
985
#if BOOST_VERSION < 104601
319
986
typename
320
987
boost::proto::detail::enable_binary<
321
988
  field_domain,
329
996
operator+ (const field_indirect_const<T,M>& l, const T& r)
330
997
{
331
998
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
332
 
    ::impl<const field_indirect_const<T,M>&,   const T&>() (l, r);
333
 
}
 
999
    ::impl<const field_indirect_const<T,M>&, const T&>() (l, r);
 
1000
}
 
1001
#else // BOOST_VERSION >= 104601
 
1002
typename boost::proto::detail::enable_binary< 
 
1003
  field_domain,
 
1004
  field_domain::proto_grammar,
 
1005
  boost::mpl::and_<
 
1006
    boost::mpl::or_<is_field<field_indirect_const<T,M> >, is_field<T > >,
 
1007
    boost::mpl::not_<
 
1008
      boost::mpl::or_<
 
1009
        boost::proto::is_extension<field_indirect_const<T,M> >,
 
1010
        boost::proto::is_extension<T >
 
1011
      >
 
1012
    >
 
1013
  >,
 
1014
  boost::proto::tag::plus,
 
1015
  field_indirect_const<T,M> const &,
 
1016
  T const &
 
1017
>::type /* const */
 
1018
operator+ (field_indirect_const<T,M> const &left, T const &right)
 
1019
{
 
1020
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect_const<T,M> const &, T const &>()(left, right);
 
1021
}
 
1022
#endif // BOOST_VERSION
 
1023
template<class T, class M>
 
1024
#if BOOST_VERSION < 104601
 
1025
typename
 
1026
boost::proto::detail::enable_binary<
 
1027
  field_domain,
 
1028
  is_field<field_component<T,M> >,
 
1029
  field_component<T,M>,
 
1030
  is_field<int >,
 
1031
  int,
 
1032
  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1033
    ::impl<const field_component<T,M>&,   const int&>::result_type const
 
1034
>::type
 
1035
operator+ (const field_component<T,M>& l, const int& r)
 
1036
{
 
1037
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1038
    ::impl<const field_component<T,M>&, const int&>() (l, r);
 
1039
}
 
1040
#else // BOOST_VERSION >= 104601
 
1041
typename boost::proto::detail::enable_binary< 
 
1042
  field_domain,
 
1043
  field_domain::proto_grammar,
 
1044
  boost::mpl::and_<
 
1045
    boost::mpl::or_<is_field<field_component<T,M> >, is_field<int > >,
 
1046
    boost::mpl::not_<
 
1047
      boost::mpl::or_<
 
1048
        boost::proto::is_extension<field_component<T,M> >,
 
1049
        boost::proto::is_extension<int >
 
1050
      >
 
1051
    >
 
1052
  >,
 
1053
  boost::proto::tag::plus,
 
1054
  field_component<T,M> const &,
 
1055
  int const &
 
1056
>::type /* const */
 
1057
operator+ (field_component<T,M> const &left, int const &right)
 
1058
{
 
1059
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component<T,M> const &, int const &>()(left, right);
 
1060
}
 
1061
#endif // BOOST_VERSION
 
1062
template<class T, class M>
 
1063
#if BOOST_VERSION < 104601
 
1064
typename
 
1065
boost::proto::detail::enable_binary<
 
1066
  field_domain,
 
1067
  is_field<field_component<T,M> >,
 
1068
  field_component<T,M>,
 
1069
  is_field<T >,
 
1070
  T,
 
1071
  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1072
    ::impl<const field_component<T,M>&,   const T&>::result_type const
 
1073
>::type
 
1074
operator+ (const field_component<T,M>& l, const T& r)
 
1075
{
 
1076
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1077
    ::impl<const field_component<T,M>&, const T&>() (l, r);
 
1078
}
 
1079
#else // BOOST_VERSION >= 104601
 
1080
typename boost::proto::detail::enable_binary< 
 
1081
  field_domain,
 
1082
  field_domain::proto_grammar,
 
1083
  boost::mpl::and_<
 
1084
    boost::mpl::or_<is_field<field_component<T,M> >, is_field<T > >,
 
1085
    boost::mpl::not_<
 
1086
      boost::mpl::or_<
 
1087
        boost::proto::is_extension<field_component<T,M> >,
 
1088
        boost::proto::is_extension<T >
 
1089
      >
 
1090
    >
 
1091
  >,
 
1092
  boost::proto::tag::plus,
 
1093
  field_component<T,M> const &,
 
1094
  T const &
 
1095
>::type /* const */
 
1096
operator+ (field_component<T,M> const &left, T const &right)
 
1097
{
 
1098
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component<T,M> const &, T const &>()(left, right);
 
1099
}
 
1100
#endif // BOOST_VERSION
 
1101
template<class T, class M>
 
1102
#if BOOST_VERSION < 104601
 
1103
typename
 
1104
boost::proto::detail::enable_binary<
 
1105
  field_domain,
 
1106
  is_field<field_component_const<T,M> >,
 
1107
  field_component_const<T,M>,
 
1108
  is_field<int >,
 
1109
  int,
 
1110
  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1111
    ::impl<const field_component_const<T,M>&,   const int&>::result_type const
 
1112
>::type
 
1113
operator+ (const field_component_const<T,M>& l, const int& r)
 
1114
{
 
1115
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1116
    ::impl<const field_component_const<T,M>&, const int&>() (l, r);
 
1117
}
 
1118
#else // BOOST_VERSION >= 104601
 
1119
typename boost::proto::detail::enable_binary< 
 
1120
  field_domain,
 
1121
  field_domain::proto_grammar,
 
1122
  boost::mpl::and_<
 
1123
    boost::mpl::or_<is_field<field_component_const<T,M> >, is_field<int > >,
 
1124
    boost::mpl::not_<
 
1125
      boost::mpl::or_<
 
1126
        boost::proto::is_extension<field_component_const<T,M> >,
 
1127
        boost::proto::is_extension<int >
 
1128
      >
 
1129
    >
 
1130
  >,
 
1131
  boost::proto::tag::plus,
 
1132
  field_component_const<T,M> const &,
 
1133
  int const &
 
1134
>::type /* const */
 
1135
operator+ (field_component_const<T,M> const &left, int const &right)
 
1136
{
 
1137
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component_const<T,M> const &, int const &>()(left, right);
 
1138
}
 
1139
#endif // BOOST_VERSION
 
1140
template<class T, class M>
 
1141
#if BOOST_VERSION < 104601
 
1142
typename
 
1143
boost::proto::detail::enable_binary<
 
1144
  field_domain,
 
1145
  is_field<field_component_const<T,M> >,
 
1146
  field_component_const<T,M>,
 
1147
  is_field<T >,
 
1148
  T,
 
1149
  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1150
    ::impl<const field_component_const<T,M>&,   const T&>::result_type const
 
1151
>::type
 
1152
operator+ (const field_component_const<T,M>& l, const T& r)
 
1153
{
 
1154
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1155
    ::impl<const field_component_const<T,M>&, const T&>() (l, r);
 
1156
}
 
1157
#else // BOOST_VERSION >= 104601
 
1158
typename boost::proto::detail::enable_binary< 
 
1159
  field_domain,
 
1160
  field_domain::proto_grammar,
 
1161
  boost::mpl::and_<
 
1162
    boost::mpl::or_<is_field<field_component_const<T,M> >, is_field<T > >,
 
1163
    boost::mpl::not_<
 
1164
      boost::mpl::or_<
 
1165
        boost::proto::is_extension<field_component_const<T,M> >,
 
1166
        boost::proto::is_extension<T >
 
1167
      >
 
1168
    >
 
1169
  >,
 
1170
  boost::proto::tag::plus,
 
1171
  field_component_const<T,M> const &,
 
1172
  T const &
 
1173
>::type /* const */
 
1174
operator+ (field_component_const<T,M> const &left, T const &right)
 
1175
{
 
1176
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component_const<T,M> const &, T const &>()(left, right);
 
1177
}
 
1178
#endif // BOOST_VERSION
334
1179
template<class T1, class T2, class M>
 
1180
#if BOOST_VERSION < 104601
335
1181
typename
336
1182
boost::proto::detail::enable_binary<
337
1183
  field_domain,
345
1191
operator+ (const field_basic<T1,M>& l, const field_basic<T2,M>& r)
346
1192
{
347
1193
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
348
 
    ::impl<const field_basic<T1,M>&,   const field_basic<T2,M>&>() (l, r);
349
 
}
 
1194
    ::impl<const field_basic<T1,M>&, const field_basic<T2,M>&>() (l, r);
 
1195
}
 
1196
#else // BOOST_VERSION >= 104601
 
1197
typename boost::proto::detail::enable_binary< 
 
1198
  field_domain,
 
1199
  field_domain::proto_grammar,
 
1200
  boost::mpl::and_<
 
1201
    boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_basic<T2,M> > >,
 
1202
    boost::mpl::not_<
 
1203
      boost::mpl::or_<
 
1204
        boost::proto::is_extension<field_basic<T1,M> >,
 
1205
        boost::proto::is_extension<field_basic<T2,M> >
 
1206
      >
 
1207
    >
 
1208
  >,
 
1209
  boost::proto::tag::plus,
 
1210
  field_basic<T1,M> const &,
 
1211
  field_basic<T2,M> const &
 
1212
>::type /* const */
 
1213
operator+ (field_basic<T1,M> const &left, field_basic<T2,M> const &right)
 
1214
{
 
1215
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_basic<T1,M> const &, field_basic<T2,M> const &>()(left, right);
 
1216
}
 
1217
#endif // BOOST_VERSION
350
1218
template<class T1, class T2, class M>
 
1219
#if BOOST_VERSION < 104601
351
1220
typename
352
1221
boost::proto::detail::enable_binary<
353
1222
  field_domain,
361
1230
operator+ (const field_basic<T1,M>& l, const field_indirect<T2,M>& r)
362
1231
{
363
1232
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
364
 
    ::impl<const field_basic<T1,M>&,   const field_indirect<T2,M>&>() (l, r);
365
 
}
 
1233
    ::impl<const field_basic<T1,M>&, const field_indirect<T2,M>&>() (l, r);
 
1234
}
 
1235
#else // BOOST_VERSION >= 104601
 
1236
typename boost::proto::detail::enable_binary< 
 
1237
  field_domain,
 
1238
  field_domain::proto_grammar,
 
1239
  boost::mpl::and_<
 
1240
    boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_indirect<T2,M> > >,
 
1241
    boost::mpl::not_<
 
1242
      boost::mpl::or_<
 
1243
        boost::proto::is_extension<field_basic<T1,M> >,
 
1244
        boost::proto::is_extension<field_indirect<T2,M> >
 
1245
      >
 
1246
    >
 
1247
  >,
 
1248
  boost::proto::tag::plus,
 
1249
  field_basic<T1,M> const &,
 
1250
  field_indirect<T2,M> const &
 
1251
>::type /* const */
 
1252
operator+ (field_basic<T1,M> const &left, field_indirect<T2,M> const &right)
 
1253
{
 
1254
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_basic<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
 
1255
}
 
1256
#endif // BOOST_VERSION
366
1257
template<class T1, class T2, class M>
 
1258
#if BOOST_VERSION < 104601
367
1259
typename
368
1260
boost::proto::detail::enable_binary<
369
1261
  field_domain,
377
1269
operator+ (const field_basic<T1,M>& l, const field_indirect_const<T2,M>& r)
378
1270
{
379
1271
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
380
 
    ::impl<const field_basic<T1,M>&,   const field_indirect_const<T2,M>&>() (l, r);
381
 
}
382
 
template<class T1, class T2, class M>
 
1272
    ::impl<const field_basic<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
 
1273
}
 
1274
#else // BOOST_VERSION >= 104601
 
1275
typename boost::proto::detail::enable_binary< 
 
1276
  field_domain,
 
1277
  field_domain::proto_grammar,
 
1278
  boost::mpl::and_<
 
1279
    boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_indirect_const<T2,M> > >,
 
1280
    boost::mpl::not_<
 
1281
      boost::mpl::or_<
 
1282
        boost::proto::is_extension<field_basic<T1,M> >,
 
1283
        boost::proto::is_extension<field_indirect_const<T2,M> >
 
1284
      >
 
1285
    >
 
1286
  >,
 
1287
  boost::proto::tag::plus,
 
1288
  field_basic<T1,M> const &,
 
1289
  field_indirect_const<T2,M> const &
 
1290
>::type /* const */
 
1291
operator+ (field_basic<T1,M> const &left, field_indirect_const<T2,M> const &right)
 
1292
{
 
1293
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_basic<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
 
1294
}
 
1295
#endif // BOOST_VERSION
 
1296
template<class T1, class T2, class M>
 
1297
#if BOOST_VERSION < 104601
 
1298
typename
 
1299
boost::proto::detail::enable_binary<
 
1300
  field_domain,
 
1301
  is_field<field_basic<T1,M> >,
 
1302
  field_basic<T1,M>,
 
1303
  is_field<field_component<T2,M> >,
 
1304
  field_component<T2,M>,
 
1305
  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1306
    ::impl<const field_basic<T1,M>&,   const field_component<T2,M>&>::result_type const
 
1307
>::type
 
1308
operator+ (const field_basic<T1,M>& l, const field_component<T2,M>& r)
 
1309
{
 
1310
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1311
    ::impl<const field_basic<T1,M>&, const field_component<T2,M>&>() (l, r);
 
1312
}
 
1313
#else // BOOST_VERSION >= 104601
 
1314
typename boost::proto::detail::enable_binary< 
 
1315
  field_domain,
 
1316
  field_domain::proto_grammar,
 
1317
  boost::mpl::and_<
 
1318
    boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_component<T2,M> > >,
 
1319
    boost::mpl::not_<
 
1320
      boost::mpl::or_<
 
1321
        boost::proto::is_extension<field_basic<T1,M> >,
 
1322
        boost::proto::is_extension<field_component<T2,M> >
 
1323
      >
 
1324
    >
 
1325
  >,
 
1326
  boost::proto::tag::plus,
 
1327
  field_basic<T1,M> const &,
 
1328
  field_component<T2,M> const &
 
1329
>::type /* const */
 
1330
operator+ (field_basic<T1,M> const &left, field_component<T2,M> const &right)
 
1331
{
 
1332
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_basic<T1,M> const &, field_component<T2,M> const &>()(left, right);
 
1333
}
 
1334
#endif // BOOST_VERSION
 
1335
template<class T1, class T2, class M>
 
1336
#if BOOST_VERSION < 104601
 
1337
typename
 
1338
boost::proto::detail::enable_binary<
 
1339
  field_domain,
 
1340
  is_field<field_basic<T1,M> >,
 
1341
  field_basic<T1,M>,
 
1342
  is_field<field_component_const<T2,M> >,
 
1343
  field_component_const<T2,M>,
 
1344
  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1345
    ::impl<const field_basic<T1,M>&,   const field_component_const<T2,M>&>::result_type const
 
1346
>::type
 
1347
operator+ (const field_basic<T1,M>& l, const field_component_const<T2,M>& r)
 
1348
{
 
1349
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1350
    ::impl<const field_basic<T1,M>&, const field_component_const<T2,M>&>() (l, r);
 
1351
}
 
1352
#else // BOOST_VERSION >= 104601
 
1353
typename boost::proto::detail::enable_binary< 
 
1354
  field_domain,
 
1355
  field_domain::proto_grammar,
 
1356
  boost::mpl::and_<
 
1357
    boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_component_const<T2,M> > >,
 
1358
    boost::mpl::not_<
 
1359
      boost::mpl::or_<
 
1360
        boost::proto::is_extension<field_basic<T1,M> >,
 
1361
        boost::proto::is_extension<field_component_const<T2,M> >
 
1362
      >
 
1363
    >
 
1364
  >,
 
1365
  boost::proto::tag::plus,
 
1366
  field_basic<T1,M> const &,
 
1367
  field_component_const<T2,M> const &
 
1368
>::type /* const */
 
1369
operator+ (field_basic<T1,M> const &left, field_component_const<T2,M> const &right)
 
1370
{
 
1371
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_basic<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
 
1372
}
 
1373
#endif // BOOST_VERSION
 
1374
template<class T1, class T2, class M>
 
1375
#if BOOST_VERSION < 104601
383
1376
typename
384
1377
boost::proto::detail::enable_binary<
385
1378
  field_domain,
393
1386
operator+ (const field_indirect<T1,M>& l, const field_basic<T2,M>& r)
394
1387
{
395
1388
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
396
 
    ::impl<const field_indirect<T1,M>&,   const field_basic<T2,M>&>() (l, r);
397
 
}
 
1389
    ::impl<const field_indirect<T1,M>&, const field_basic<T2,M>&>() (l, r);
 
1390
}
 
1391
#else // BOOST_VERSION >= 104601
 
1392
typename boost::proto::detail::enable_binary< 
 
1393
  field_domain,
 
1394
  field_domain::proto_grammar,
 
1395
  boost::mpl::and_<
 
1396
    boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_basic<T2,M> > >,
 
1397
    boost::mpl::not_<
 
1398
      boost::mpl::or_<
 
1399
        boost::proto::is_extension<field_indirect<T1,M> >,
 
1400
        boost::proto::is_extension<field_basic<T2,M> >
 
1401
      >
 
1402
    >
 
1403
  >,
 
1404
  boost::proto::tag::plus,
 
1405
  field_indirect<T1,M> const &,
 
1406
  field_basic<T2,M> const &
 
1407
>::type /* const */
 
1408
operator+ (field_indirect<T1,M> const &left, field_basic<T2,M> const &right)
 
1409
{
 
1410
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect<T1,M> const &, field_basic<T2,M> const &>()(left, right);
 
1411
}
 
1412
#endif // BOOST_VERSION
398
1413
template<class T1, class T2, class M>
 
1414
#if BOOST_VERSION < 104601
399
1415
typename
400
1416
boost::proto::detail::enable_binary<
401
1417
  field_domain,
409
1425
operator+ (const field_indirect<T1,M>& l, const field_indirect<T2,M>& r)
410
1426
{
411
1427
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
412
 
    ::impl<const field_indirect<T1,M>&,   const field_indirect<T2,M>&>() (l, r);
413
 
}
 
1428
    ::impl<const field_indirect<T1,M>&, const field_indirect<T2,M>&>() (l, r);
 
1429
}
 
1430
#else // BOOST_VERSION >= 104601
 
1431
typename boost::proto::detail::enable_binary< 
 
1432
  field_domain,
 
1433
  field_domain::proto_grammar,
 
1434
  boost::mpl::and_<
 
1435
    boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_indirect<T2,M> > >,
 
1436
    boost::mpl::not_<
 
1437
      boost::mpl::or_<
 
1438
        boost::proto::is_extension<field_indirect<T1,M> >,
 
1439
        boost::proto::is_extension<field_indirect<T2,M> >
 
1440
      >
 
1441
    >
 
1442
  >,
 
1443
  boost::proto::tag::plus,
 
1444
  field_indirect<T1,M> const &,
 
1445
  field_indirect<T2,M> const &
 
1446
>::type /* const */
 
1447
operator+ (field_indirect<T1,M> const &left, field_indirect<T2,M> const &right)
 
1448
{
 
1449
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
 
1450
}
 
1451
#endif // BOOST_VERSION
414
1452
template<class T1, class T2, class M>
 
1453
#if BOOST_VERSION < 104601
415
1454
typename
416
1455
boost::proto::detail::enable_binary<
417
1456
  field_domain,
425
1464
operator+ (const field_indirect<T1,M>& l, const field_indirect_const<T2,M>& r)
426
1465
{
427
1466
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
428
 
    ::impl<const field_indirect<T1,M>&,   const field_indirect_const<T2,M>&>() (l, r);
429
 
}
430
 
template<class T1, class T2, class M>
 
1467
    ::impl<const field_indirect<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
 
1468
}
 
1469
#else // BOOST_VERSION >= 104601
 
1470
typename boost::proto::detail::enable_binary< 
 
1471
  field_domain,
 
1472
  field_domain::proto_grammar,
 
1473
  boost::mpl::and_<
 
1474
    boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_indirect_const<T2,M> > >,
 
1475
    boost::mpl::not_<
 
1476
      boost::mpl::or_<
 
1477
        boost::proto::is_extension<field_indirect<T1,M> >,
 
1478
        boost::proto::is_extension<field_indirect_const<T2,M> >
 
1479
      >
 
1480
    >
 
1481
  >,
 
1482
  boost::proto::tag::plus,
 
1483
  field_indirect<T1,M> const &,
 
1484
  field_indirect_const<T2,M> const &
 
1485
>::type /* const */
 
1486
operator+ (field_indirect<T1,M> const &left, field_indirect_const<T2,M> const &right)
 
1487
{
 
1488
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
 
1489
}
 
1490
#endif // BOOST_VERSION
 
1491
template<class T1, class T2, class M>
 
1492
#if BOOST_VERSION < 104601
 
1493
typename
 
1494
boost::proto::detail::enable_binary<
 
1495
  field_domain,
 
1496
  is_field<field_indirect<T1,M> >,
 
1497
  field_indirect<T1,M>,
 
1498
  is_field<field_component<T2,M> >,
 
1499
  field_component<T2,M>,
 
1500
  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1501
    ::impl<const field_indirect<T1,M>&,   const field_component<T2,M>&>::result_type const
 
1502
>::type
 
1503
operator+ (const field_indirect<T1,M>& l, const field_component<T2,M>& r)
 
1504
{
 
1505
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1506
    ::impl<const field_indirect<T1,M>&, const field_component<T2,M>&>() (l, r);
 
1507
}
 
1508
#else // BOOST_VERSION >= 104601
 
1509
typename boost::proto::detail::enable_binary< 
 
1510
  field_domain,
 
1511
  field_domain::proto_grammar,
 
1512
  boost::mpl::and_<
 
1513
    boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_component<T2,M> > >,
 
1514
    boost::mpl::not_<
 
1515
      boost::mpl::or_<
 
1516
        boost::proto::is_extension<field_indirect<T1,M> >,
 
1517
        boost::proto::is_extension<field_component<T2,M> >
 
1518
      >
 
1519
    >
 
1520
  >,
 
1521
  boost::proto::tag::plus,
 
1522
  field_indirect<T1,M> const &,
 
1523
  field_component<T2,M> const &
 
1524
>::type /* const */
 
1525
operator+ (field_indirect<T1,M> const &left, field_component<T2,M> const &right)
 
1526
{
 
1527
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect<T1,M> const &, field_component<T2,M> const &>()(left, right);
 
1528
}
 
1529
#endif // BOOST_VERSION
 
1530
template<class T1, class T2, class M>
 
1531
#if BOOST_VERSION < 104601
 
1532
typename
 
1533
boost::proto::detail::enable_binary<
 
1534
  field_domain,
 
1535
  is_field<field_indirect<T1,M> >,
 
1536
  field_indirect<T1,M>,
 
1537
  is_field<field_component_const<T2,M> >,
 
1538
  field_component_const<T2,M>,
 
1539
  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1540
    ::impl<const field_indirect<T1,M>&,   const field_component_const<T2,M>&>::result_type const
 
1541
>::type
 
1542
operator+ (const field_indirect<T1,M>& l, const field_component_const<T2,M>& r)
 
1543
{
 
1544
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1545
    ::impl<const field_indirect<T1,M>&, const field_component_const<T2,M>&>() (l, r);
 
1546
}
 
1547
#else // BOOST_VERSION >= 104601
 
1548
typename boost::proto::detail::enable_binary< 
 
1549
  field_domain,
 
1550
  field_domain::proto_grammar,
 
1551
  boost::mpl::and_<
 
1552
    boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_component_const<T2,M> > >,
 
1553
    boost::mpl::not_<
 
1554
      boost::mpl::or_<
 
1555
        boost::proto::is_extension<field_indirect<T1,M> >,
 
1556
        boost::proto::is_extension<field_component_const<T2,M> >
 
1557
      >
 
1558
    >
 
1559
  >,
 
1560
  boost::proto::tag::plus,
 
1561
  field_indirect<T1,M> const &,
 
1562
  field_component_const<T2,M> const &
 
1563
>::type /* const */
 
1564
operator+ (field_indirect<T1,M> const &left, field_component_const<T2,M> const &right)
 
1565
{
 
1566
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
 
1567
}
 
1568
#endif // BOOST_VERSION
 
1569
template<class T1, class T2, class M>
 
1570
#if BOOST_VERSION < 104601
431
1571
typename
432
1572
boost::proto::detail::enable_binary<
433
1573
  field_domain,
441
1581
operator+ (const field_indirect_const<T1,M>& l, const field_basic<T2,M>& r)
442
1582
{
443
1583
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
444
 
    ::impl<const field_indirect_const<T1,M>&,   const field_basic<T2,M>&>() (l, r);
445
 
}
 
1584
    ::impl<const field_indirect_const<T1,M>&, const field_basic<T2,M>&>() (l, r);
 
1585
}
 
1586
#else // BOOST_VERSION >= 104601
 
1587
typename boost::proto::detail::enable_binary< 
 
1588
  field_domain,
 
1589
  field_domain::proto_grammar,
 
1590
  boost::mpl::and_<
 
1591
    boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_basic<T2,M> > >,
 
1592
    boost::mpl::not_<
 
1593
      boost::mpl::or_<
 
1594
        boost::proto::is_extension<field_indirect_const<T1,M> >,
 
1595
        boost::proto::is_extension<field_basic<T2,M> >
 
1596
      >
 
1597
    >
 
1598
  >,
 
1599
  boost::proto::tag::plus,
 
1600
  field_indirect_const<T1,M> const &,
 
1601
  field_basic<T2,M> const &
 
1602
>::type /* const */
 
1603
operator+ (field_indirect_const<T1,M> const &left, field_basic<T2,M> const &right)
 
1604
{
 
1605
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect_const<T1,M> const &, field_basic<T2,M> const &>()(left, right);
 
1606
}
 
1607
#endif // BOOST_VERSION
446
1608
template<class T1, class T2, class M>
 
1609
#if BOOST_VERSION < 104601
447
1610
typename
448
1611
boost::proto::detail::enable_binary<
449
1612
  field_domain,
457
1620
operator+ (const field_indirect_const<T1,M>& l, const field_indirect<T2,M>& r)
458
1621
{
459
1622
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
460
 
    ::impl<const field_indirect_const<T1,M>&,   const field_indirect<T2,M>&>() (l, r);
461
 
}
 
1623
    ::impl<const field_indirect_const<T1,M>&, const field_indirect<T2,M>&>() (l, r);
 
1624
}
 
1625
#else // BOOST_VERSION >= 104601
 
1626
typename boost::proto::detail::enable_binary< 
 
1627
  field_domain,
 
1628
  field_domain::proto_grammar,
 
1629
  boost::mpl::and_<
 
1630
    boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_indirect<T2,M> > >,
 
1631
    boost::mpl::not_<
 
1632
      boost::mpl::or_<
 
1633
        boost::proto::is_extension<field_indirect_const<T1,M> >,
 
1634
        boost::proto::is_extension<field_indirect<T2,M> >
 
1635
      >
 
1636
    >
 
1637
  >,
 
1638
  boost::proto::tag::plus,
 
1639
  field_indirect_const<T1,M> const &,
 
1640
  field_indirect<T2,M> const &
 
1641
>::type /* const */
 
1642
operator+ (field_indirect_const<T1,M> const &left, field_indirect<T2,M> const &right)
 
1643
{
 
1644
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect_const<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
 
1645
}
 
1646
#endif // BOOST_VERSION
462
1647
template<class T1, class T2, class M>
 
1648
#if BOOST_VERSION < 104601
463
1649
typename
464
1650
boost::proto::detail::enable_binary<
465
1651
  field_domain,
473
1659
operator+ (const field_indirect_const<T1,M>& l, const field_indirect_const<T2,M>& r)
474
1660
{
475
1661
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
476
 
    ::impl<const field_indirect_const<T1,M>&,   const field_indirect_const<T2,M>&>() (l, r);
477
 
}
 
1662
    ::impl<const field_indirect_const<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
 
1663
}
 
1664
#else // BOOST_VERSION >= 104601
 
1665
typename boost::proto::detail::enable_binary< 
 
1666
  field_domain,
 
1667
  field_domain::proto_grammar,
 
1668
  boost::mpl::and_<
 
1669
    boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_indirect_const<T2,M> > >,
 
1670
    boost::mpl::not_<
 
1671
      boost::mpl::or_<
 
1672
        boost::proto::is_extension<field_indirect_const<T1,M> >,
 
1673
        boost::proto::is_extension<field_indirect_const<T2,M> >
 
1674
      >
 
1675
    >
 
1676
  >,
 
1677
  boost::proto::tag::plus,
 
1678
  field_indirect_const<T1,M> const &,
 
1679
  field_indirect_const<T2,M> const &
 
1680
>::type /* const */
 
1681
operator+ (field_indirect_const<T1,M> const &left, field_indirect_const<T2,M> const &right)
 
1682
{
 
1683
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect_const<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
 
1684
}
 
1685
#endif // BOOST_VERSION
 
1686
template<class T1, class T2, class M>
 
1687
#if BOOST_VERSION < 104601
 
1688
typename
 
1689
boost::proto::detail::enable_binary<
 
1690
  field_domain,
 
1691
  is_field<field_indirect_const<T1,M> >,
 
1692
  field_indirect_const<T1,M>,
 
1693
  is_field<field_component<T2,M> >,
 
1694
  field_component<T2,M>,
 
1695
  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1696
    ::impl<const field_indirect_const<T1,M>&,   const field_component<T2,M>&>::result_type const
 
1697
>::type
 
1698
operator+ (const field_indirect_const<T1,M>& l, const field_component<T2,M>& r)
 
1699
{
 
1700
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1701
    ::impl<const field_indirect_const<T1,M>&, const field_component<T2,M>&>() (l, r);
 
1702
}
 
1703
#else // BOOST_VERSION >= 104601
 
1704
typename boost::proto::detail::enable_binary< 
 
1705
  field_domain,
 
1706
  field_domain::proto_grammar,
 
1707
  boost::mpl::and_<
 
1708
    boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_component<T2,M> > >,
 
1709
    boost::mpl::not_<
 
1710
      boost::mpl::or_<
 
1711
        boost::proto::is_extension<field_indirect_const<T1,M> >,
 
1712
        boost::proto::is_extension<field_component<T2,M> >
 
1713
      >
 
1714
    >
 
1715
  >,
 
1716
  boost::proto::tag::plus,
 
1717
  field_indirect_const<T1,M> const &,
 
1718
  field_component<T2,M> const &
 
1719
>::type /* const */
 
1720
operator+ (field_indirect_const<T1,M> const &left, field_component<T2,M> const &right)
 
1721
{
 
1722
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect_const<T1,M> const &, field_component<T2,M> const &>()(left, right);
 
1723
}
 
1724
#endif // BOOST_VERSION
 
1725
template<class T1, class T2, class M>
 
1726
#if BOOST_VERSION < 104601
 
1727
typename
 
1728
boost::proto::detail::enable_binary<
 
1729
  field_domain,
 
1730
  is_field<field_indirect_const<T1,M> >,
 
1731
  field_indirect_const<T1,M>,
 
1732
  is_field<field_component_const<T2,M> >,
 
1733
  field_component_const<T2,M>,
 
1734
  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1735
    ::impl<const field_indirect_const<T1,M>&,   const field_component_const<T2,M>&>::result_type const
 
1736
>::type
 
1737
operator+ (const field_indirect_const<T1,M>& l, const field_component_const<T2,M>& r)
 
1738
{
 
1739
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1740
    ::impl<const field_indirect_const<T1,M>&, const field_component_const<T2,M>&>() (l, r);
 
1741
}
 
1742
#else // BOOST_VERSION >= 104601
 
1743
typename boost::proto::detail::enable_binary< 
 
1744
  field_domain,
 
1745
  field_domain::proto_grammar,
 
1746
  boost::mpl::and_<
 
1747
    boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_component_const<T2,M> > >,
 
1748
    boost::mpl::not_<
 
1749
      boost::mpl::or_<
 
1750
        boost::proto::is_extension<field_indirect_const<T1,M> >,
 
1751
        boost::proto::is_extension<field_component_const<T2,M> >
 
1752
      >
 
1753
    >
 
1754
  >,
 
1755
  boost::proto::tag::plus,
 
1756
  field_indirect_const<T1,M> const &,
 
1757
  field_component_const<T2,M> const &
 
1758
>::type /* const */
 
1759
operator+ (field_indirect_const<T1,M> const &left, field_component_const<T2,M> const &right)
 
1760
{
 
1761
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect_const<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
 
1762
}
 
1763
#endif // BOOST_VERSION
 
1764
template<class T1, class T2, class M>
 
1765
#if BOOST_VERSION < 104601
 
1766
typename
 
1767
boost::proto::detail::enable_binary<
 
1768
  field_domain,
 
1769
  is_field<field_component<T1,M> >,
 
1770
  field_component<T1,M>,
 
1771
  is_field<field_basic<T2,M> >,
 
1772
  field_basic<T2,M>,
 
1773
  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1774
    ::impl<const field_component<T1,M>&,   const field_basic<T2,M>&>::result_type const
 
1775
>::type
 
1776
operator+ (const field_component<T1,M>& l, const field_basic<T2,M>& r)
 
1777
{
 
1778
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1779
    ::impl<const field_component<T1,M>&, const field_basic<T2,M>&>() (l, r);
 
1780
}
 
1781
#else // BOOST_VERSION >= 104601
 
1782
typename boost::proto::detail::enable_binary< 
 
1783
  field_domain,
 
1784
  field_domain::proto_grammar,
 
1785
  boost::mpl::and_<
 
1786
    boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_basic<T2,M> > >,
 
1787
    boost::mpl::not_<
 
1788
      boost::mpl::or_<
 
1789
        boost::proto::is_extension<field_component<T1,M> >,
 
1790
        boost::proto::is_extension<field_basic<T2,M> >
 
1791
      >
 
1792
    >
 
1793
  >,
 
1794
  boost::proto::tag::plus,
 
1795
  field_component<T1,M> const &,
 
1796
  field_basic<T2,M> const &
 
1797
>::type /* const */
 
1798
operator+ (field_component<T1,M> const &left, field_basic<T2,M> const &right)
 
1799
{
 
1800
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component<T1,M> const &, field_basic<T2,M> const &>()(left, right);
 
1801
}
 
1802
#endif // BOOST_VERSION
 
1803
template<class T1, class T2, class M>
 
1804
#if BOOST_VERSION < 104601
 
1805
typename
 
1806
boost::proto::detail::enable_binary<
 
1807
  field_domain,
 
1808
  is_field<field_component<T1,M> >,
 
1809
  field_component<T1,M>,
 
1810
  is_field<field_indirect<T2,M> >,
 
1811
  field_indirect<T2,M>,
 
1812
  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1813
    ::impl<const field_component<T1,M>&,   const field_indirect<T2,M>&>::result_type const
 
1814
>::type
 
1815
operator+ (const field_component<T1,M>& l, const field_indirect<T2,M>& r)
 
1816
{
 
1817
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1818
    ::impl<const field_component<T1,M>&, const field_indirect<T2,M>&>() (l, r);
 
1819
}
 
1820
#else // BOOST_VERSION >= 104601
 
1821
typename boost::proto::detail::enable_binary< 
 
1822
  field_domain,
 
1823
  field_domain::proto_grammar,
 
1824
  boost::mpl::and_<
 
1825
    boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_indirect<T2,M> > >,
 
1826
    boost::mpl::not_<
 
1827
      boost::mpl::or_<
 
1828
        boost::proto::is_extension<field_component<T1,M> >,
 
1829
        boost::proto::is_extension<field_indirect<T2,M> >
 
1830
      >
 
1831
    >
 
1832
  >,
 
1833
  boost::proto::tag::plus,
 
1834
  field_component<T1,M> const &,
 
1835
  field_indirect<T2,M> const &
 
1836
>::type /* const */
 
1837
operator+ (field_component<T1,M> const &left, field_indirect<T2,M> const &right)
 
1838
{
 
1839
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
 
1840
}
 
1841
#endif // BOOST_VERSION
 
1842
template<class T1, class T2, class M>
 
1843
#if BOOST_VERSION < 104601
 
1844
typename
 
1845
boost::proto::detail::enable_binary<
 
1846
  field_domain,
 
1847
  is_field<field_component<T1,M> >,
 
1848
  field_component<T1,M>,
 
1849
  is_field<field_indirect_const<T2,M> >,
 
1850
  field_indirect_const<T2,M>,
 
1851
  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1852
    ::impl<const field_component<T1,M>&,   const field_indirect_const<T2,M>&>::result_type const
 
1853
>::type
 
1854
operator+ (const field_component<T1,M>& l, const field_indirect_const<T2,M>& r)
 
1855
{
 
1856
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1857
    ::impl<const field_component<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
 
1858
}
 
1859
#else // BOOST_VERSION >= 104601
 
1860
typename boost::proto::detail::enable_binary< 
 
1861
  field_domain,
 
1862
  field_domain::proto_grammar,
 
1863
  boost::mpl::and_<
 
1864
    boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_indirect_const<T2,M> > >,
 
1865
    boost::mpl::not_<
 
1866
      boost::mpl::or_<
 
1867
        boost::proto::is_extension<field_component<T1,M> >,
 
1868
        boost::proto::is_extension<field_indirect_const<T2,M> >
 
1869
      >
 
1870
    >
 
1871
  >,
 
1872
  boost::proto::tag::plus,
 
1873
  field_component<T1,M> const &,
 
1874
  field_indirect_const<T2,M> const &
 
1875
>::type /* const */
 
1876
operator+ (field_component<T1,M> const &left, field_indirect_const<T2,M> const &right)
 
1877
{
 
1878
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
 
1879
}
 
1880
#endif // BOOST_VERSION
 
1881
template<class T1, class T2, class M>
 
1882
#if BOOST_VERSION < 104601
 
1883
typename
 
1884
boost::proto::detail::enable_binary<
 
1885
  field_domain,
 
1886
  is_field<field_component<T1,M> >,
 
1887
  field_component<T1,M>,
 
1888
  is_field<field_component<T2,M> >,
 
1889
  field_component<T2,M>,
 
1890
  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1891
    ::impl<const field_component<T1,M>&,   const field_component<T2,M>&>::result_type const
 
1892
>::type
 
1893
operator+ (const field_component<T1,M>& l, const field_component<T2,M>& r)
 
1894
{
 
1895
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1896
    ::impl<const field_component<T1,M>&, const field_component<T2,M>&>() (l, r);
 
1897
}
 
1898
#else // BOOST_VERSION >= 104601
 
1899
typename boost::proto::detail::enable_binary< 
 
1900
  field_domain,
 
1901
  field_domain::proto_grammar,
 
1902
  boost::mpl::and_<
 
1903
    boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_component<T2,M> > >,
 
1904
    boost::mpl::not_<
 
1905
      boost::mpl::or_<
 
1906
        boost::proto::is_extension<field_component<T1,M> >,
 
1907
        boost::proto::is_extension<field_component<T2,M> >
 
1908
      >
 
1909
    >
 
1910
  >,
 
1911
  boost::proto::tag::plus,
 
1912
  field_component<T1,M> const &,
 
1913
  field_component<T2,M> const &
 
1914
>::type /* const */
 
1915
operator+ (field_component<T1,M> const &left, field_component<T2,M> const &right)
 
1916
{
 
1917
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component<T1,M> const &, field_component<T2,M> const &>()(left, right);
 
1918
}
 
1919
#endif // BOOST_VERSION
 
1920
template<class T1, class T2, class M>
 
1921
#if BOOST_VERSION < 104601
 
1922
typename
 
1923
boost::proto::detail::enable_binary<
 
1924
  field_domain,
 
1925
  is_field<field_component<T1,M> >,
 
1926
  field_component<T1,M>,
 
1927
  is_field<field_component_const<T2,M> >,
 
1928
  field_component_const<T2,M>,
 
1929
  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1930
    ::impl<const field_component<T1,M>&,   const field_component_const<T2,M>&>::result_type const
 
1931
>::type
 
1932
operator+ (const field_component<T1,M>& l, const field_component_const<T2,M>& r)
 
1933
{
 
1934
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1935
    ::impl<const field_component<T1,M>&, const field_component_const<T2,M>&>() (l, r);
 
1936
}
 
1937
#else // BOOST_VERSION >= 104601
 
1938
typename boost::proto::detail::enable_binary< 
 
1939
  field_domain,
 
1940
  field_domain::proto_grammar,
 
1941
  boost::mpl::and_<
 
1942
    boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_component_const<T2,M> > >,
 
1943
    boost::mpl::not_<
 
1944
      boost::mpl::or_<
 
1945
        boost::proto::is_extension<field_component<T1,M> >,
 
1946
        boost::proto::is_extension<field_component_const<T2,M> >
 
1947
      >
 
1948
    >
 
1949
  >,
 
1950
  boost::proto::tag::plus,
 
1951
  field_component<T1,M> const &,
 
1952
  field_component_const<T2,M> const &
 
1953
>::type /* const */
 
1954
operator+ (field_component<T1,M> const &left, field_component_const<T2,M> const &right)
 
1955
{
 
1956
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
 
1957
}
 
1958
#endif // BOOST_VERSION
 
1959
template<class T1, class T2, class M>
 
1960
#if BOOST_VERSION < 104601
 
1961
typename
 
1962
boost::proto::detail::enable_binary<
 
1963
  field_domain,
 
1964
  is_field<field_component_const<T1,M> >,
 
1965
  field_component_const<T1,M>,
 
1966
  is_field<field_basic<T2,M> >,
 
1967
  field_basic<T2,M>,
 
1968
  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1969
    ::impl<const field_component_const<T1,M>&,   const field_basic<T2,M>&>::result_type const
 
1970
>::type
 
1971
operator+ (const field_component_const<T1,M>& l, const field_basic<T2,M>& r)
 
1972
{
 
1973
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
1974
    ::impl<const field_component_const<T1,M>&, const field_basic<T2,M>&>() (l, r);
 
1975
}
 
1976
#else // BOOST_VERSION >= 104601
 
1977
typename boost::proto::detail::enable_binary< 
 
1978
  field_domain,
 
1979
  field_domain::proto_grammar,
 
1980
  boost::mpl::and_<
 
1981
    boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_basic<T2,M> > >,
 
1982
    boost::mpl::not_<
 
1983
      boost::mpl::or_<
 
1984
        boost::proto::is_extension<field_component_const<T1,M> >,
 
1985
        boost::proto::is_extension<field_basic<T2,M> >
 
1986
      >
 
1987
    >
 
1988
  >,
 
1989
  boost::proto::tag::plus,
 
1990
  field_component_const<T1,M> const &,
 
1991
  field_basic<T2,M> const &
 
1992
>::type /* const */
 
1993
operator+ (field_component_const<T1,M> const &left, field_basic<T2,M> const &right)
 
1994
{
 
1995
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component_const<T1,M> const &, field_basic<T2,M> const &>()(left, right);
 
1996
}
 
1997
#endif // BOOST_VERSION
 
1998
template<class T1, class T2, class M>
 
1999
#if BOOST_VERSION < 104601
 
2000
typename
 
2001
boost::proto::detail::enable_binary<
 
2002
  field_domain,
 
2003
  is_field<field_component_const<T1,M> >,
 
2004
  field_component_const<T1,M>,
 
2005
  is_field<field_indirect<T2,M> >,
 
2006
  field_indirect<T2,M>,
 
2007
  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
2008
    ::impl<const field_component_const<T1,M>&,   const field_indirect<T2,M>&>::result_type const
 
2009
>::type
 
2010
operator+ (const field_component_const<T1,M>& l, const field_indirect<T2,M>& r)
 
2011
{
 
2012
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
2013
    ::impl<const field_component_const<T1,M>&, const field_indirect<T2,M>&>() (l, r);
 
2014
}
 
2015
#else // BOOST_VERSION >= 104601
 
2016
typename boost::proto::detail::enable_binary< 
 
2017
  field_domain,
 
2018
  field_domain::proto_grammar,
 
2019
  boost::mpl::and_<
 
2020
    boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_indirect<T2,M> > >,
 
2021
    boost::mpl::not_<
 
2022
      boost::mpl::or_<
 
2023
        boost::proto::is_extension<field_component_const<T1,M> >,
 
2024
        boost::proto::is_extension<field_indirect<T2,M> >
 
2025
      >
 
2026
    >
 
2027
  >,
 
2028
  boost::proto::tag::plus,
 
2029
  field_component_const<T1,M> const &,
 
2030
  field_indirect<T2,M> const &
 
2031
>::type /* const */
 
2032
operator+ (field_component_const<T1,M> const &left, field_indirect<T2,M> const &right)
 
2033
{
 
2034
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component_const<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
 
2035
}
 
2036
#endif // BOOST_VERSION
 
2037
template<class T1, class T2, class M>
 
2038
#if BOOST_VERSION < 104601
 
2039
typename
 
2040
boost::proto::detail::enable_binary<
 
2041
  field_domain,
 
2042
  is_field<field_component_const<T1,M> >,
 
2043
  field_component_const<T1,M>,
 
2044
  is_field<field_indirect_const<T2,M> >,
 
2045
  field_indirect_const<T2,M>,
 
2046
  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
2047
    ::impl<const field_component_const<T1,M>&,   const field_indirect_const<T2,M>&>::result_type const
 
2048
>::type
 
2049
operator+ (const field_component_const<T1,M>& l, const field_indirect_const<T2,M>& r)
 
2050
{
 
2051
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
2052
    ::impl<const field_component_const<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
 
2053
}
 
2054
#else // BOOST_VERSION >= 104601
 
2055
typename boost::proto::detail::enable_binary< 
 
2056
  field_domain,
 
2057
  field_domain::proto_grammar,
 
2058
  boost::mpl::and_<
 
2059
    boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_indirect_const<T2,M> > >,
 
2060
    boost::mpl::not_<
 
2061
      boost::mpl::or_<
 
2062
        boost::proto::is_extension<field_component_const<T1,M> >,
 
2063
        boost::proto::is_extension<field_indirect_const<T2,M> >
 
2064
      >
 
2065
    >
 
2066
  >,
 
2067
  boost::proto::tag::plus,
 
2068
  field_component_const<T1,M> const &,
 
2069
  field_indirect_const<T2,M> const &
 
2070
>::type /* const */
 
2071
operator+ (field_component_const<T1,M> const &left, field_indirect_const<T2,M> const &right)
 
2072
{
 
2073
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component_const<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
 
2074
}
 
2075
#endif // BOOST_VERSION
 
2076
template<class T1, class T2, class M>
 
2077
#if BOOST_VERSION < 104601
 
2078
typename
 
2079
boost::proto::detail::enable_binary<
 
2080
  field_domain,
 
2081
  is_field<field_component_const<T1,M> >,
 
2082
  field_component_const<T1,M>,
 
2083
  is_field<field_component<T2,M> >,
 
2084
  field_component<T2,M>,
 
2085
  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
2086
    ::impl<const field_component_const<T1,M>&,   const field_component<T2,M>&>::result_type const
 
2087
>::type
 
2088
operator+ (const field_component_const<T1,M>& l, const field_component<T2,M>& r)
 
2089
{
 
2090
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
2091
    ::impl<const field_component_const<T1,M>&, const field_component<T2,M>&>() (l, r);
 
2092
}
 
2093
#else // BOOST_VERSION >= 104601
 
2094
typename boost::proto::detail::enable_binary< 
 
2095
  field_domain,
 
2096
  field_domain::proto_grammar,
 
2097
  boost::mpl::and_<
 
2098
    boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_component<T2,M> > >,
 
2099
    boost::mpl::not_<
 
2100
      boost::mpl::or_<
 
2101
        boost::proto::is_extension<field_component_const<T1,M> >,
 
2102
        boost::proto::is_extension<field_component<T2,M> >
 
2103
      >
 
2104
    >
 
2105
  >,
 
2106
  boost::proto::tag::plus,
 
2107
  field_component_const<T1,M> const &,
 
2108
  field_component<T2,M> const &
 
2109
>::type /* const */
 
2110
operator+ (field_component_const<T1,M> const &left, field_component<T2,M> const &right)
 
2111
{
 
2112
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component_const<T1,M> const &, field_component<T2,M> const &>()(left, right);
 
2113
}
 
2114
#endif // BOOST_VERSION
 
2115
template<class T1, class T2, class M>
 
2116
#if BOOST_VERSION < 104601
 
2117
typename
 
2118
boost::proto::detail::enable_binary<
 
2119
  field_domain,
 
2120
  is_field<field_component_const<T1,M> >,
 
2121
  field_component_const<T1,M>,
 
2122
  is_field<field_component_const<T2,M> >,
 
2123
  field_component_const<T2,M>,
 
2124
  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
2125
    ::impl<const field_component_const<T1,M>&,   const field_component_const<T2,M>&>::result_type const
 
2126
>::type
 
2127
operator+ (const field_component_const<T1,M>& l, const field_component_const<T2,M>& r)
 
2128
{
 
2129
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
2130
    ::impl<const field_component_const<T1,M>&, const field_component_const<T2,M>&>() (l, r);
 
2131
}
 
2132
#else // BOOST_VERSION >= 104601
 
2133
typename boost::proto::detail::enable_binary< 
 
2134
  field_domain,
 
2135
  field_domain::proto_grammar,
 
2136
  boost::mpl::and_<
 
2137
    boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_component_const<T2,M> > >,
 
2138
    boost::mpl::not_<
 
2139
      boost::mpl::or_<
 
2140
        boost::proto::is_extension<field_component_const<T1,M> >,
 
2141
        boost::proto::is_extension<field_component_const<T2,M> >
 
2142
      >
 
2143
    >
 
2144
  >,
 
2145
  boost::proto::tag::plus,
 
2146
  field_component_const<T1,M> const &,
 
2147
  field_component_const<T2,M> const &
 
2148
>::type /* const */
 
2149
operator+ (field_component_const<T1,M> const &left, field_component_const<T2,M> const &right)
 
2150
{
 
2151
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component_const<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
 
2152
}
 
2153
#endif // BOOST_VERSION
478
2154
template<class Expr>
 
2155
#if BOOST_VERSION < 104601
479
2156
typename
480
2157
boost::proto::detail::enable_binary<
481
2158
  field_domain,
489
2166
operator+ (const int& l, const field_expr<Expr>& r)
490
2167
{
491
2168
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
492
 
    ::impl<const int&,   const field_expr<Expr>&>() (l, r);
493
 
}
 
2169
    ::impl<const int&, const field_expr<Expr>&>() (l, r);
 
2170
}
 
2171
#else // BOOST_VERSION >= 104601
 
2172
typename boost::proto::detail::enable_binary< 
 
2173
  field_domain,
 
2174
  field_domain::proto_grammar,
 
2175
  boost::mpl::and_<
 
2176
    boost::mpl::or_<is_field<int >, is_field<field_expr<Expr> > >,
 
2177
    boost::mpl::not_<
 
2178
      boost::mpl::or_<
 
2179
        boost::proto::is_extension<int >,
 
2180
        boost::proto::is_extension<field_expr<Expr> >
 
2181
      >
 
2182
    >
 
2183
  >,
 
2184
  boost::proto::tag::plus,
 
2185
  int const &,
 
2186
  field_expr<Expr> const &
 
2187
>::type /* const */
 
2188
operator+ (int const &left, field_expr<Expr> const &right)
 
2189
{
 
2190
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, int const &, field_expr<Expr> const &>()(left, right);
 
2191
}
 
2192
#endif // BOOST_VERSION
494
2193
template<class Expr>
 
2194
#if BOOST_VERSION < 104601
495
2195
typename
496
2196
boost::proto::detail::enable_binary<
497
2197
  field_domain,
505
2205
operator+ (const field_expr<Expr>& l, const int& r)
506
2206
{
507
2207
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
508
 
    ::impl<const field_expr<Expr>&,   const int&>() (l, r);
509
 
}
 
2208
    ::impl<const field_expr<Expr>&, const int&>() (l, r);
 
2209
}
 
2210
#else // BOOST_VERSION >= 104601
 
2211
typename boost::proto::detail::enable_binary< 
 
2212
  field_domain,
 
2213
  field_domain::proto_grammar,
 
2214
  boost::mpl::and_<
 
2215
    boost::mpl::or_<is_field<field_expr<Expr> >, is_field<int > >,
 
2216
    boost::mpl::not_<
 
2217
      boost::mpl::or_<
 
2218
        boost::proto::is_extension<field_expr<Expr> >,
 
2219
        boost::proto::is_extension<int >
 
2220
      >
 
2221
    >
 
2222
  >,
 
2223
  boost::proto::tag::plus,
 
2224
  field_expr<Expr> const &,
 
2225
  int const &
 
2226
>::type /* const */
 
2227
operator+ (field_expr<Expr> const &left, int const &right)
 
2228
{
 
2229
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_expr<Expr> const &, int const &>()(left, right);
 
2230
}
 
2231
#endif // BOOST_VERSION
510
2232
template<class T, class Expr>
 
2233
#if BOOST_VERSION < 104601
511
2234
typename
512
2235
boost::proto::detail::enable_binary<
513
2236
  field_domain,
521
2244
operator+ (const T& l, const field_expr<Expr>& r)
522
2245
{
523
2246
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
524
 
    ::impl<const T&,   const field_expr<Expr>&>() (l, r);
525
 
}
 
2247
    ::impl<const T&, const field_expr<Expr>&>() (l, r);
 
2248
}
 
2249
#else // BOOST_VERSION >= 104601
 
2250
typename boost::proto::detail::enable_binary< 
 
2251
  field_domain,
 
2252
  field_domain::proto_grammar,
 
2253
  boost::mpl::and_<
 
2254
    boost::mpl::or_<is_field<T >, is_field<field_expr<Expr> > >,
 
2255
    boost::mpl::not_<
 
2256
      boost::mpl::or_<
 
2257
        boost::proto::is_extension<T >,
 
2258
        boost::proto::is_extension<field_expr<Expr> >
 
2259
      >
 
2260
    >
 
2261
  >,
 
2262
  boost::proto::tag::plus,
 
2263
  T const &,
 
2264
  field_expr<Expr> const &
 
2265
>::type /* const */
 
2266
operator+ (T const &left, field_expr<Expr> const &right)
 
2267
{
 
2268
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, T const &, field_expr<Expr> const &>()(left, right);
 
2269
}
 
2270
#endif // BOOST_VERSION
526
2271
template<class T, class Expr>
 
2272
#if BOOST_VERSION < 104601
527
2273
typename
528
2274
boost::proto::detail::enable_binary<
529
2275
  field_domain,
537
2283
operator+ (const field_expr<Expr>& l, const T& r)
538
2284
{
539
2285
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
540
 
    ::impl<const field_expr<Expr>&,   const T&>() (l, r);
541
 
}
 
2286
    ::impl<const field_expr<Expr>&, const T&>() (l, r);
 
2287
}
 
2288
#else // BOOST_VERSION >= 104601
 
2289
typename boost::proto::detail::enable_binary< 
 
2290
  field_domain,
 
2291
  field_domain::proto_grammar,
 
2292
  boost::mpl::and_<
 
2293
    boost::mpl::or_<is_field<field_expr<Expr> >, is_field<T > >,
 
2294
    boost::mpl::not_<
 
2295
      boost::mpl::or_<
 
2296
        boost::proto::is_extension<field_expr<Expr> >,
 
2297
        boost::proto::is_extension<T >
 
2298
      >
 
2299
    >
 
2300
  >,
 
2301
  boost::proto::tag::plus,
 
2302
  field_expr<Expr> const &,
 
2303
  T const &
 
2304
>::type /* const */
 
2305
operator+ (field_expr<Expr> const &left, T const &right)
 
2306
{
 
2307
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_expr<Expr> const &, T const &>()(left, right);
 
2308
}
 
2309
#endif // BOOST_VERSION
542
2310
template<class T, class M, class Expr>
 
2311
#if BOOST_VERSION < 104601
543
2312
typename
544
2313
boost::proto::detail::enable_binary<
545
2314
  field_domain,
553
2322
operator+ (const field_basic<T,M>& l, const field_expr<Expr>& r)
554
2323
{
555
2324
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
556
 
    ::impl<const field_basic<T,M>&,   const field_expr<Expr>&>() (l, r);
557
 
}
 
2325
    ::impl<const field_basic<T,M>&, const field_expr<Expr>&>() (l, r);
 
2326
}
 
2327
#else // BOOST_VERSION >= 104601
 
2328
typename boost::proto::detail::enable_binary< 
 
2329
  field_domain,
 
2330
  field_domain::proto_grammar,
 
2331
  boost::mpl::and_<
 
2332
    boost::mpl::or_<is_field<field_basic<T,M> >, is_field<field_expr<Expr> > >,
 
2333
    boost::mpl::not_<
 
2334
      boost::mpl::or_<
 
2335
        boost::proto::is_extension<field_basic<T,M> >,
 
2336
        boost::proto::is_extension<field_expr<Expr> >
 
2337
      >
 
2338
    >
 
2339
  >,
 
2340
  boost::proto::tag::plus,
 
2341
  field_basic<T,M> const &,
 
2342
  field_expr<Expr> const &
 
2343
>::type /* const */
 
2344
operator+ (field_basic<T,M> const &left, field_expr<Expr> const &right)
 
2345
{
 
2346
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_basic<T,M> const &, field_expr<Expr> const &>()(left, right);
 
2347
}
 
2348
#endif // BOOST_VERSION
558
2349
template<class T, class M, class Expr>
 
2350
#if BOOST_VERSION < 104601
559
2351
typename
560
2352
boost::proto::detail::enable_binary<
561
2353
  field_domain,
569
2361
operator+ (const field_expr<Expr>& l, const field_basic<T,M>& r)
570
2362
{
571
2363
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
572
 
    ::impl<const field_expr<Expr>&,   const field_basic<T,M>&>() (l, r);
573
 
}
 
2364
    ::impl<const field_expr<Expr>&, const field_basic<T,M>&>() (l, r);
 
2365
}
 
2366
#else // BOOST_VERSION >= 104601
 
2367
typename boost::proto::detail::enable_binary< 
 
2368
  field_domain,
 
2369
  field_domain::proto_grammar,
 
2370
  boost::mpl::and_<
 
2371
    boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_basic<T,M> > >,
 
2372
    boost::mpl::not_<
 
2373
      boost::mpl::or_<
 
2374
        boost::proto::is_extension<field_expr<Expr> >,
 
2375
        boost::proto::is_extension<field_basic<T,M> >
 
2376
      >
 
2377
    >
 
2378
  >,
 
2379
  boost::proto::tag::plus,
 
2380
  field_expr<Expr> const &,
 
2381
  field_basic<T,M> const &
 
2382
>::type /* const */
 
2383
operator+ (field_expr<Expr> const &left, field_basic<T,M> const &right)
 
2384
{
 
2385
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_expr<Expr> const &, field_basic<T,M> const &>()(left, right);
 
2386
}
 
2387
#endif // BOOST_VERSION
574
2388
template<class T, class M, class Expr>
 
2389
#if BOOST_VERSION < 104601
575
2390
typename
576
2391
boost::proto::detail::enable_binary<
577
2392
  field_domain,
585
2400
operator+ (const field_indirect<T,M>& l, const field_expr<Expr>& r)
586
2401
{
587
2402
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
588
 
    ::impl<const field_indirect<T,M>&,   const field_expr<Expr>&>() (l, r);
589
 
}
 
2403
    ::impl<const field_indirect<T,M>&, const field_expr<Expr>&>() (l, r);
 
2404
}
 
2405
#else // BOOST_VERSION >= 104601
 
2406
typename boost::proto::detail::enable_binary< 
 
2407
  field_domain,
 
2408
  field_domain::proto_grammar,
 
2409
  boost::mpl::and_<
 
2410
    boost::mpl::or_<is_field<field_indirect<T,M> >, is_field<field_expr<Expr> > >,
 
2411
    boost::mpl::not_<
 
2412
      boost::mpl::or_<
 
2413
        boost::proto::is_extension<field_indirect<T,M> >,
 
2414
        boost::proto::is_extension<field_expr<Expr> >
 
2415
      >
 
2416
    >
 
2417
  >,
 
2418
  boost::proto::tag::plus,
 
2419
  field_indirect<T,M> const &,
 
2420
  field_expr<Expr> const &
 
2421
>::type /* const */
 
2422
operator+ (field_indirect<T,M> const &left, field_expr<Expr> const &right)
 
2423
{
 
2424
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect<T,M> const &, field_expr<Expr> const &>()(left, right);
 
2425
}
 
2426
#endif // BOOST_VERSION
590
2427
template<class T, class M, class Expr>
 
2428
#if BOOST_VERSION < 104601
591
2429
typename
592
2430
boost::proto::detail::enable_binary<
593
2431
  field_domain,
601
2439
operator+ (const field_expr<Expr>& l, const field_indirect<T,M>& r)
602
2440
{
603
2441
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
604
 
    ::impl<const field_expr<Expr>&,   const field_indirect<T,M>&>() (l, r);
605
 
}
 
2442
    ::impl<const field_expr<Expr>&, const field_indirect<T,M>&>() (l, r);
 
2443
}
 
2444
#else // BOOST_VERSION >= 104601
 
2445
typename boost::proto::detail::enable_binary< 
 
2446
  field_domain,
 
2447
  field_domain::proto_grammar,
 
2448
  boost::mpl::and_<
 
2449
    boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_indirect<T,M> > >,
 
2450
    boost::mpl::not_<
 
2451
      boost::mpl::or_<
 
2452
        boost::proto::is_extension<field_expr<Expr> >,
 
2453
        boost::proto::is_extension<field_indirect<T,M> >
 
2454
      >
 
2455
    >
 
2456
  >,
 
2457
  boost::proto::tag::plus,
 
2458
  field_expr<Expr> const &,
 
2459
  field_indirect<T,M> const &
 
2460
>::type /* const */
 
2461
operator+ (field_expr<Expr> const &left, field_indirect<T,M> const &right)
 
2462
{
 
2463
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_expr<Expr> const &, field_indirect<T,M> const &>()(left, right);
 
2464
}
 
2465
#endif // BOOST_VERSION
606
2466
template<class T, class M, class Expr>
 
2467
#if BOOST_VERSION < 104601
607
2468
typename
608
2469
boost::proto::detail::enable_binary<
609
2470
  field_domain,
617
2478
operator+ (const field_indirect_const<T,M>& l, const field_expr<Expr>& r)
618
2479
{
619
2480
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
620
 
    ::impl<const field_indirect_const<T,M>&,   const field_expr<Expr>&>() (l, r);
621
 
}
 
2481
    ::impl<const field_indirect_const<T,M>&, const field_expr<Expr>&>() (l, r);
 
2482
}
 
2483
#else // BOOST_VERSION >= 104601
 
2484
typename boost::proto::detail::enable_binary< 
 
2485
  field_domain,
 
2486
  field_domain::proto_grammar,
 
2487
  boost::mpl::and_<
 
2488
    boost::mpl::or_<is_field<field_indirect_const<T,M> >, is_field<field_expr<Expr> > >,
 
2489
    boost::mpl::not_<
 
2490
      boost::mpl::or_<
 
2491
        boost::proto::is_extension<field_indirect_const<T,M> >,
 
2492
        boost::proto::is_extension<field_expr<Expr> >
 
2493
      >
 
2494
    >
 
2495
  >,
 
2496
  boost::proto::tag::plus,
 
2497
  field_indirect_const<T,M> const &,
 
2498
  field_expr<Expr> const &
 
2499
>::type /* const */
 
2500
operator+ (field_indirect_const<T,M> const &left, field_expr<Expr> const &right)
 
2501
{
 
2502
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect_const<T,M> const &, field_expr<Expr> const &>()(left, right);
 
2503
}
 
2504
#endif // BOOST_VERSION
622
2505
template<class T, class M, class Expr>
 
2506
#if BOOST_VERSION < 104601
623
2507
typename
624
2508
boost::proto::detail::enable_binary<
625
2509
  field_domain,
633
2517
operator+ (const field_expr<Expr>& l, const field_indirect_const<T,M>& r)
634
2518
{
635
2519
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
636
 
    ::impl<const field_expr<Expr>&,   const field_indirect_const<T,M>&>() (l, r);
637
 
}
 
2520
    ::impl<const field_expr<Expr>&, const field_indirect_const<T,M>&>() (l, r);
 
2521
}
 
2522
#else // BOOST_VERSION >= 104601
 
2523
typename boost::proto::detail::enable_binary< 
 
2524
  field_domain,
 
2525
  field_domain::proto_grammar,
 
2526
  boost::mpl::and_<
 
2527
    boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_indirect_const<T,M> > >,
 
2528
    boost::mpl::not_<
 
2529
      boost::mpl::or_<
 
2530
        boost::proto::is_extension<field_expr<Expr> >,
 
2531
        boost::proto::is_extension<field_indirect_const<T,M> >
 
2532
      >
 
2533
    >
 
2534
  >,
 
2535
  boost::proto::tag::plus,
 
2536
  field_expr<Expr> const &,
 
2537
  field_indirect_const<T,M> const &
 
2538
>::type /* const */
 
2539
operator+ (field_expr<Expr> const &left, field_indirect_const<T,M> const &right)
 
2540
{
 
2541
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_expr<Expr> const &, field_indirect_const<T,M> const &>()(left, right);
 
2542
}
 
2543
#endif // BOOST_VERSION
 
2544
template<class T, class M, class Expr>
 
2545
#if BOOST_VERSION < 104601
 
2546
typename
 
2547
boost::proto::detail::enable_binary<
 
2548
  field_domain,
 
2549
  is_field<field_component<T,M> >,
 
2550
  field_component<T,M>,
 
2551
  is_field<field_expr<Expr> >,
 
2552
  field_expr<Expr>,
 
2553
  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
2554
    ::impl<const field_component<T,M>&,   const field_expr<Expr>&>::result_type const
 
2555
>::type
 
2556
operator+ (const field_component<T,M>& l, const field_expr<Expr>& r)
 
2557
{
 
2558
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
2559
    ::impl<const field_component<T,M>&, const field_expr<Expr>&>() (l, r);
 
2560
}
 
2561
#else // BOOST_VERSION >= 104601
 
2562
typename boost::proto::detail::enable_binary< 
 
2563
  field_domain,
 
2564
  field_domain::proto_grammar,
 
2565
  boost::mpl::and_<
 
2566
    boost::mpl::or_<is_field<field_component<T,M> >, is_field<field_expr<Expr> > >,
 
2567
    boost::mpl::not_<
 
2568
      boost::mpl::or_<
 
2569
        boost::proto::is_extension<field_component<T,M> >,
 
2570
        boost::proto::is_extension<field_expr<Expr> >
 
2571
      >
 
2572
    >
 
2573
  >,
 
2574
  boost::proto::tag::plus,
 
2575
  field_component<T,M> const &,
 
2576
  field_expr<Expr> const &
 
2577
>::type /* const */
 
2578
operator+ (field_component<T,M> const &left, field_expr<Expr> const &right)
 
2579
{
 
2580
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component<T,M> const &, field_expr<Expr> const &>()(left, right);
 
2581
}
 
2582
#endif // BOOST_VERSION
 
2583
template<class T, class M, class Expr>
 
2584
#if BOOST_VERSION < 104601
 
2585
typename
 
2586
boost::proto::detail::enable_binary<
 
2587
  field_domain,
 
2588
  is_field<field_expr<Expr> >,
 
2589
  field_expr<Expr>,
 
2590
  is_field<field_component<T,M> >,
 
2591
  field_component<T,M>,
 
2592
  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
2593
    ::impl<const field_expr<Expr>&,   const field_component<T,M>&>::result_type const
 
2594
>::type
 
2595
operator+ (const field_expr<Expr>& l, const field_component<T,M>& r)
 
2596
{
 
2597
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
2598
    ::impl<const field_expr<Expr>&, const field_component<T,M>&>() (l, r);
 
2599
}
 
2600
#else // BOOST_VERSION >= 104601
 
2601
typename boost::proto::detail::enable_binary< 
 
2602
  field_domain,
 
2603
  field_domain::proto_grammar,
 
2604
  boost::mpl::and_<
 
2605
    boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_component<T,M> > >,
 
2606
    boost::mpl::not_<
 
2607
      boost::mpl::or_<
 
2608
        boost::proto::is_extension<field_expr<Expr> >,
 
2609
        boost::proto::is_extension<field_component<T,M> >
 
2610
      >
 
2611
    >
 
2612
  >,
 
2613
  boost::proto::tag::plus,
 
2614
  field_expr<Expr> const &,
 
2615
  field_component<T,M> const &
 
2616
>::type /* const */
 
2617
operator+ (field_expr<Expr> const &left, field_component<T,M> const &right)
 
2618
{
 
2619
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_expr<Expr> const &, field_component<T,M> const &>()(left, right);
 
2620
}
 
2621
#endif // BOOST_VERSION
 
2622
template<class T, class M, class Expr>
 
2623
#if BOOST_VERSION < 104601
 
2624
typename
 
2625
boost::proto::detail::enable_binary<
 
2626
  field_domain,
 
2627
  is_field<field_component_const<T,M> >,
 
2628
  field_component_const<T,M>,
 
2629
  is_field<field_expr<Expr> >,
 
2630
  field_expr<Expr>,
 
2631
  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
2632
    ::impl<const field_component_const<T,M>&,   const field_expr<Expr>&>::result_type const
 
2633
>::type
 
2634
operator+ (const field_component_const<T,M>& l, const field_expr<Expr>& r)
 
2635
{
 
2636
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
2637
    ::impl<const field_component_const<T,M>&, const field_expr<Expr>&>() (l, r);
 
2638
}
 
2639
#else // BOOST_VERSION >= 104601
 
2640
typename boost::proto::detail::enable_binary< 
 
2641
  field_domain,
 
2642
  field_domain::proto_grammar,
 
2643
  boost::mpl::and_<
 
2644
    boost::mpl::or_<is_field<field_component_const<T,M> >, is_field<field_expr<Expr> > >,
 
2645
    boost::mpl::not_<
 
2646
      boost::mpl::or_<
 
2647
        boost::proto::is_extension<field_component_const<T,M> >,
 
2648
        boost::proto::is_extension<field_expr<Expr> >
 
2649
      >
 
2650
    >
 
2651
  >,
 
2652
  boost::proto::tag::plus,
 
2653
  field_component_const<T,M> const &,
 
2654
  field_expr<Expr> const &
 
2655
>::type /* const */
 
2656
operator+ (field_component_const<T,M> const &left, field_expr<Expr> const &right)
 
2657
{
 
2658
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component_const<T,M> const &, field_expr<Expr> const &>()(left, right);
 
2659
}
 
2660
#endif // BOOST_VERSION
 
2661
template<class T, class M, class Expr>
 
2662
#if BOOST_VERSION < 104601
 
2663
typename
 
2664
boost::proto::detail::enable_binary<
 
2665
  field_domain,
 
2666
  is_field<field_expr<Expr> >,
 
2667
  field_expr<Expr>,
 
2668
  is_field<field_component_const<T,M> >,
 
2669
  field_component_const<T,M>,
 
2670
  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
2671
    ::impl<const field_expr<Expr>&,   const field_component_const<T,M>&>::result_type const
 
2672
>::type
 
2673
operator+ (const field_expr<Expr>& l, const field_component_const<T,M>& r)
 
2674
{
 
2675
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
 
2676
    ::impl<const field_expr<Expr>&, const field_component_const<T,M>&>() (l, r);
 
2677
}
 
2678
#else // BOOST_VERSION >= 104601
 
2679
typename boost::proto::detail::enable_binary< 
 
2680
  field_domain,
 
2681
  field_domain::proto_grammar,
 
2682
  boost::mpl::and_<
 
2683
    boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_component_const<T,M> > >,
 
2684
    boost::mpl::not_<
 
2685
      boost::mpl::or_<
 
2686
        boost::proto::is_extension<field_expr<Expr> >,
 
2687
        boost::proto::is_extension<field_component_const<T,M> >
 
2688
      >
 
2689
    >
 
2690
  >,
 
2691
  boost::proto::tag::plus,
 
2692
  field_expr<Expr> const &,
 
2693
  field_component_const<T,M> const &
 
2694
>::type /* const */
 
2695
operator+ (field_expr<Expr> const &left, field_component_const<T,M> const &right)
 
2696
{
 
2697
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_expr<Expr> const &, field_component_const<T,M> const &>()(left, right);
 
2698
}
 
2699
#endif // BOOST_VERSION
638
2700
template<class Expr1, class Expr2>
 
2701
#if BOOST_VERSION < 104601
639
2702
typename
640
2703
boost::proto::detail::enable_binary<
641
2704
  field_domain,
649
2712
operator+ (const field_expr<Expr1>& l, const field_expr<Expr2>& r)
650
2713
{
651
2714
  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
652
 
    ::impl<const field_expr<Expr1>&,   const field_expr<Expr2>&>() (l, r);
653
 
}
 
2715
    ::impl<const field_expr<Expr1>&, const field_expr<Expr2>&>() (l, r);
 
2716
}
 
2717
#else // BOOST_VERSION >= 104601
 
2718
typename boost::proto::detail::enable_binary< 
 
2719
  field_domain,
 
2720
  field_domain::proto_grammar,
 
2721
  boost::mpl::and_<
 
2722
    boost::mpl::or_<is_field<field_expr<Expr1> >, is_field<field_expr<Expr2> > >,
 
2723
    boost::mpl::not_<
 
2724
      boost::mpl::or_<
 
2725
        boost::proto::is_extension<field_expr<Expr1> >,
 
2726
        boost::proto::is_extension<field_expr<Expr2> >
 
2727
      >
 
2728
    >
 
2729
  >,
 
2730
  boost::proto::tag::plus,
 
2731
  field_expr<Expr1> const &,
 
2732
  field_expr<Expr2> const &
 
2733
>::type /* const */
 
2734
operator+ (field_expr<Expr1> const &left, field_expr<Expr2> const &right)
 
2735
{
 
2736
  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_expr<Expr1> const &, field_expr<Expr2> const &>()(left, right);
 
2737
}
 
2738
#endif // BOOST_VERSION
654
2739
template<class T, class M>
 
2740
#if BOOST_VERSION < 104601
655
2741
typename
656
2742
boost::proto::detail::enable_binary<
657
2743
  field_domain,
665
2751
operator- (const int& l, const field_basic<T,M>& r)
666
2752
{
667
2753
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
668
 
    ::impl<const int&,   const field_basic<T,M>&>() (l, r);
669
 
}
 
2754
    ::impl<const int&, const field_basic<T,M>&>() (l, r);
 
2755
}
 
2756
#else // BOOST_VERSION >= 104601
 
2757
typename boost::proto::detail::enable_binary< 
 
2758
  field_domain,
 
2759
  field_domain::proto_grammar,
 
2760
  boost::mpl::and_<
 
2761
    boost::mpl::or_<is_field<int >, is_field<field_basic<T,M> > >,
 
2762
    boost::mpl::not_<
 
2763
      boost::mpl::or_<
 
2764
        boost::proto::is_extension<int >,
 
2765
        boost::proto::is_extension<field_basic<T,M> >
 
2766
      >
 
2767
    >
 
2768
  >,
 
2769
  boost::proto::tag::minus,
 
2770
  int const &,
 
2771
  field_basic<T,M> const &
 
2772
>::type /* const */
 
2773
operator- (int const &left, field_basic<T,M> const &right)
 
2774
{
 
2775
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, int const &, field_basic<T,M> const &>()(left, right);
 
2776
}
 
2777
#endif // BOOST_VERSION
670
2778
template<class T, class M>
 
2779
#if BOOST_VERSION < 104601
671
2780
typename
672
2781
boost::proto::detail::enable_binary<
673
2782
  field_domain,
681
2790
operator- (const T& l, const field_basic<T,M>& r)
682
2791
{
683
2792
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
684
 
    ::impl<const T&,   const field_basic<T,M>&>() (l, r);
685
 
}
 
2793
    ::impl<const T&, const field_basic<T,M>&>() (l, r);
 
2794
}
 
2795
#else // BOOST_VERSION >= 104601
 
2796
typename boost::proto::detail::enable_binary< 
 
2797
  field_domain,
 
2798
  field_domain::proto_grammar,
 
2799
  boost::mpl::and_<
 
2800
    boost::mpl::or_<is_field<T >, is_field<field_basic<T,M> > >,
 
2801
    boost::mpl::not_<
 
2802
      boost::mpl::or_<
 
2803
        boost::proto::is_extension<T >,
 
2804
        boost::proto::is_extension<field_basic<T,M> >
 
2805
      >
 
2806
    >
 
2807
  >,
 
2808
  boost::proto::tag::minus,
 
2809
  T const &,
 
2810
  field_basic<T,M> const &
 
2811
>::type /* const */
 
2812
operator- (T const &left, field_basic<T,M> const &right)
 
2813
{
 
2814
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, T const &, field_basic<T,M> const &>()(left, right);
 
2815
}
 
2816
#endif // BOOST_VERSION
686
2817
template<class T, class M>
 
2818
#if BOOST_VERSION < 104601
687
2819
typename
688
2820
boost::proto::detail::enable_binary<
689
2821
  field_domain,
697
2829
operator- (const int& l, const field_indirect<T,M>& r)
698
2830
{
699
2831
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
700
 
    ::impl<const int&,   const field_indirect<T,M>&>() (l, r);
701
 
}
 
2832
    ::impl<const int&, const field_indirect<T,M>&>() (l, r);
 
2833
}
 
2834
#else // BOOST_VERSION >= 104601
 
2835
typename boost::proto::detail::enable_binary< 
 
2836
  field_domain,
 
2837
  field_domain::proto_grammar,
 
2838
  boost::mpl::and_<
 
2839
    boost::mpl::or_<is_field<int >, is_field<field_indirect<T,M> > >,
 
2840
    boost::mpl::not_<
 
2841
      boost::mpl::or_<
 
2842
        boost::proto::is_extension<int >,
 
2843
        boost::proto::is_extension<field_indirect<T,M> >
 
2844
      >
 
2845
    >
 
2846
  >,
 
2847
  boost::proto::tag::minus,
 
2848
  int const &,
 
2849
  field_indirect<T,M> const &
 
2850
>::type /* const */
 
2851
operator- (int const &left, field_indirect<T,M> const &right)
 
2852
{
 
2853
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, int const &, field_indirect<T,M> const &>()(left, right);
 
2854
}
 
2855
#endif // BOOST_VERSION
702
2856
template<class T, class M>
 
2857
#if BOOST_VERSION < 104601
703
2858
typename
704
2859
boost::proto::detail::enable_binary<
705
2860
  field_domain,
713
2868
operator- (const T& l, const field_indirect<T,M>& r)
714
2869
{
715
2870
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
716
 
    ::impl<const T&,   const field_indirect<T,M>&>() (l, r);
717
 
}
 
2871
    ::impl<const T&, const field_indirect<T,M>&>() (l, r);
 
2872
}
 
2873
#else // BOOST_VERSION >= 104601
 
2874
typename boost::proto::detail::enable_binary< 
 
2875
  field_domain,
 
2876
  field_domain::proto_grammar,
 
2877
  boost::mpl::and_<
 
2878
    boost::mpl::or_<is_field<T >, is_field<field_indirect<T,M> > >,
 
2879
    boost::mpl::not_<
 
2880
      boost::mpl::or_<
 
2881
        boost::proto::is_extension<T >,
 
2882
        boost::proto::is_extension<field_indirect<T,M> >
 
2883
      >
 
2884
    >
 
2885
  >,
 
2886
  boost::proto::tag::minus,
 
2887
  T const &,
 
2888
  field_indirect<T,M> const &
 
2889
>::type /* const */
 
2890
operator- (T const &left, field_indirect<T,M> const &right)
 
2891
{
 
2892
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, T const &, field_indirect<T,M> const &>()(left, right);
 
2893
}
 
2894
#endif // BOOST_VERSION
718
2895
template<class T, class M>
 
2896
#if BOOST_VERSION < 104601
719
2897
typename
720
2898
boost::proto::detail::enable_binary<
721
2899
  field_domain,
729
2907
operator- (const int& l, const field_indirect_const<T,M>& r)
730
2908
{
731
2909
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
732
 
    ::impl<const int&,   const field_indirect_const<T,M>&>() (l, r);
733
 
}
 
2910
    ::impl<const int&, const field_indirect_const<T,M>&>() (l, r);
 
2911
}
 
2912
#else // BOOST_VERSION >= 104601
 
2913
typename boost::proto::detail::enable_binary< 
 
2914
  field_domain,
 
2915
  field_domain::proto_grammar,
 
2916
  boost::mpl::and_<
 
2917
    boost::mpl::or_<is_field<int >, is_field<field_indirect_const<T,M> > >,
 
2918
    boost::mpl::not_<
 
2919
      boost::mpl::or_<
 
2920
        boost::proto::is_extension<int >,
 
2921
        boost::proto::is_extension<field_indirect_const<T,M> >
 
2922
      >
 
2923
    >
 
2924
  >,
 
2925
  boost::proto::tag::minus,
 
2926
  int const &,
 
2927
  field_indirect_const<T,M> const &
 
2928
>::type /* const */
 
2929
operator- (int const &left, field_indirect_const<T,M> const &right)
 
2930
{
 
2931
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, int const &, field_indirect_const<T,M> const &>()(left, right);
 
2932
}
 
2933
#endif // BOOST_VERSION
734
2934
template<class T, class M>
 
2935
#if BOOST_VERSION < 104601
735
2936
typename
736
2937
boost::proto::detail::enable_binary<
737
2938
  field_domain,
745
2946
operator- (const T& l, const field_indirect_const<T,M>& r)
746
2947
{
747
2948
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
748
 
    ::impl<const T&,   const field_indirect_const<T,M>&>() (l, r);
749
 
}
750
 
template<class T, class M>
 
2949
    ::impl<const T&, const field_indirect_const<T,M>&>() (l, r);
 
2950
}
 
2951
#else // BOOST_VERSION >= 104601
 
2952
typename boost::proto::detail::enable_binary< 
 
2953
  field_domain,
 
2954
  field_domain::proto_grammar,
 
2955
  boost::mpl::and_<
 
2956
    boost::mpl::or_<is_field<T >, is_field<field_indirect_const<T,M> > >,
 
2957
    boost::mpl::not_<
 
2958
      boost::mpl::or_<
 
2959
        boost::proto::is_extension<T >,
 
2960
        boost::proto::is_extension<field_indirect_const<T,M> >
 
2961
      >
 
2962
    >
 
2963
  >,
 
2964
  boost::proto::tag::minus,
 
2965
  T const &,
 
2966
  field_indirect_const<T,M> const &
 
2967
>::type /* const */
 
2968
operator- (T const &left, field_indirect_const<T,M> const &right)
 
2969
{
 
2970
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, T const &, field_indirect_const<T,M> const &>()(left, right);
 
2971
}
 
2972
#endif // BOOST_VERSION
 
2973
template<class T, class M>
 
2974
#if BOOST_VERSION < 104601
 
2975
typename
 
2976
boost::proto::detail::enable_binary<
 
2977
  field_domain,
 
2978
  is_field<int >,
 
2979
  int,
 
2980
  is_field<field_component<T,M> >,
 
2981
  field_component<T,M>,
 
2982
  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
2983
    ::impl<const int&,   const field_component<T,M>&>::result_type const
 
2984
>::type
 
2985
operator- (const int& l, const field_component<T,M>& r)
 
2986
{
 
2987
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
2988
    ::impl<const int&, const field_component<T,M>&>() (l, r);
 
2989
}
 
2990
#else // BOOST_VERSION >= 104601
 
2991
typename boost::proto::detail::enable_binary< 
 
2992
  field_domain,
 
2993
  field_domain::proto_grammar,
 
2994
  boost::mpl::and_<
 
2995
    boost::mpl::or_<is_field<int >, is_field<field_component<T,M> > >,
 
2996
    boost::mpl::not_<
 
2997
      boost::mpl::or_<
 
2998
        boost::proto::is_extension<int >,
 
2999
        boost::proto::is_extension<field_component<T,M> >
 
3000
      >
 
3001
    >
 
3002
  >,
 
3003
  boost::proto::tag::minus,
 
3004
  int const &,
 
3005
  field_component<T,M> const &
 
3006
>::type /* const */
 
3007
operator- (int const &left, field_component<T,M> const &right)
 
3008
{
 
3009
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, int const &, field_component<T,M> const &>()(left, right);
 
3010
}
 
3011
#endif // BOOST_VERSION
 
3012
template<class T, class M>
 
3013
#if BOOST_VERSION < 104601
 
3014
typename
 
3015
boost::proto::detail::enable_binary<
 
3016
  field_domain,
 
3017
  is_field<T >,
 
3018
  T,
 
3019
  is_field<field_component<T,M> >,
 
3020
  field_component<T,M>,
 
3021
  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
3022
    ::impl<const T&,   const field_component<T,M>&>::result_type const
 
3023
>::type
 
3024
operator- (const T& l, const field_component<T,M>& r)
 
3025
{
 
3026
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
3027
    ::impl<const T&, const field_component<T,M>&>() (l, r);
 
3028
}
 
3029
#else // BOOST_VERSION >= 104601
 
3030
typename boost::proto::detail::enable_binary< 
 
3031
  field_domain,
 
3032
  field_domain::proto_grammar,
 
3033
  boost::mpl::and_<
 
3034
    boost::mpl::or_<is_field<T >, is_field<field_component<T,M> > >,
 
3035
    boost::mpl::not_<
 
3036
      boost::mpl::or_<
 
3037
        boost::proto::is_extension<T >,
 
3038
        boost::proto::is_extension<field_component<T,M> >
 
3039
      >
 
3040
    >
 
3041
  >,
 
3042
  boost::proto::tag::minus,
 
3043
  T const &,
 
3044
  field_component<T,M> const &
 
3045
>::type /* const */
 
3046
operator- (T const &left, field_component<T,M> const &right)
 
3047
{
 
3048
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, T const &, field_component<T,M> const &>()(left, right);
 
3049
}
 
3050
#endif // BOOST_VERSION
 
3051
template<class T, class M>
 
3052
#if BOOST_VERSION < 104601
 
3053
typename
 
3054
boost::proto::detail::enable_binary<
 
3055
  field_domain,
 
3056
  is_field<int >,
 
3057
  int,
 
3058
  is_field<field_component_const<T,M> >,
 
3059
  field_component_const<T,M>,
 
3060
  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
3061
    ::impl<const int&,   const field_component_const<T,M>&>::result_type const
 
3062
>::type
 
3063
operator- (const int& l, const field_component_const<T,M>& r)
 
3064
{
 
3065
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
3066
    ::impl<const int&, const field_component_const<T,M>&>() (l, r);
 
3067
}
 
3068
#else // BOOST_VERSION >= 104601
 
3069
typename boost::proto::detail::enable_binary< 
 
3070
  field_domain,
 
3071
  field_domain::proto_grammar,
 
3072
  boost::mpl::and_<
 
3073
    boost::mpl::or_<is_field<int >, is_field<field_component_const<T,M> > >,
 
3074
    boost::mpl::not_<
 
3075
      boost::mpl::or_<
 
3076
        boost::proto::is_extension<int >,
 
3077
        boost::proto::is_extension<field_component_const<T,M> >
 
3078
      >
 
3079
    >
 
3080
  >,
 
3081
  boost::proto::tag::minus,
 
3082
  int const &,
 
3083
  field_component_const<T,M> const &
 
3084
>::type /* const */
 
3085
operator- (int const &left, field_component_const<T,M> const &right)
 
3086
{
 
3087
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, int const &, field_component_const<T,M> const &>()(left, right);
 
3088
}
 
3089
#endif // BOOST_VERSION
 
3090
template<class T, class M>
 
3091
#if BOOST_VERSION < 104601
 
3092
typename
 
3093
boost::proto::detail::enable_binary<
 
3094
  field_domain,
 
3095
  is_field<T >,
 
3096
  T,
 
3097
  is_field<field_component_const<T,M> >,
 
3098
  field_component_const<T,M>,
 
3099
  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
3100
    ::impl<const T&,   const field_component_const<T,M>&>::result_type const
 
3101
>::type
 
3102
operator- (const T& l, const field_component_const<T,M>& r)
 
3103
{
 
3104
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
3105
    ::impl<const T&, const field_component_const<T,M>&>() (l, r);
 
3106
}
 
3107
#else // BOOST_VERSION >= 104601
 
3108
typename boost::proto::detail::enable_binary< 
 
3109
  field_domain,
 
3110
  field_domain::proto_grammar,
 
3111
  boost::mpl::and_<
 
3112
    boost::mpl::or_<is_field<T >, is_field<field_component_const<T,M> > >,
 
3113
    boost::mpl::not_<
 
3114
      boost::mpl::or_<
 
3115
        boost::proto::is_extension<T >,
 
3116
        boost::proto::is_extension<field_component_const<T,M> >
 
3117
      >
 
3118
    >
 
3119
  >,
 
3120
  boost::proto::tag::minus,
 
3121
  T const &,
 
3122
  field_component_const<T,M> const &
 
3123
>::type /* const */
 
3124
operator- (T const &left, field_component_const<T,M> const &right)
 
3125
{
 
3126
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, T const &, field_component_const<T,M> const &>()(left, right);
 
3127
}
 
3128
#endif // BOOST_VERSION
 
3129
template<class T, class M>
 
3130
#if BOOST_VERSION < 104601
751
3131
typename
752
3132
boost::proto::detail::enable_binary<
753
3133
  field_domain,
761
3141
operator- (const field_basic<T,M>& l, const int& r)
762
3142
{
763
3143
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
764
 
    ::impl<const field_basic<T,M>&,   const int&>() (l, r);
765
 
}
 
3144
    ::impl<const field_basic<T,M>&, const int&>() (l, r);
 
3145
}
 
3146
#else // BOOST_VERSION >= 104601
 
3147
typename boost::proto::detail::enable_binary< 
 
3148
  field_domain,
 
3149
  field_domain::proto_grammar,
 
3150
  boost::mpl::and_<
 
3151
    boost::mpl::or_<is_field<field_basic<T,M> >, is_field<int > >,
 
3152
    boost::mpl::not_<
 
3153
      boost::mpl::or_<
 
3154
        boost::proto::is_extension<field_basic<T,M> >,
 
3155
        boost::proto::is_extension<int >
 
3156
      >
 
3157
    >
 
3158
  >,
 
3159
  boost::proto::tag::minus,
 
3160
  field_basic<T,M> const &,
 
3161
  int const &
 
3162
>::type /* const */
 
3163
operator- (field_basic<T,M> const &left, int const &right)
 
3164
{
 
3165
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_basic<T,M> const &, int const &>()(left, right);
 
3166
}
 
3167
#endif // BOOST_VERSION
766
3168
template<class T, class M>
 
3169
#if BOOST_VERSION < 104601
767
3170
typename
768
3171
boost::proto::detail::enable_binary<
769
3172
  field_domain,
777
3180
operator- (const field_basic<T,M>& l, const T& r)
778
3181
{
779
3182
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
780
 
    ::impl<const field_basic<T,M>&,   const T&>() (l, r);
781
 
}
 
3183
    ::impl<const field_basic<T,M>&, const T&>() (l, r);
 
3184
}
 
3185
#else // BOOST_VERSION >= 104601
 
3186
typename boost::proto::detail::enable_binary< 
 
3187
  field_domain,
 
3188
  field_domain::proto_grammar,
 
3189
  boost::mpl::and_<
 
3190
    boost::mpl::or_<is_field<field_basic<T,M> >, is_field<T > >,
 
3191
    boost::mpl::not_<
 
3192
      boost::mpl::or_<
 
3193
        boost::proto::is_extension<field_basic<T,M> >,
 
3194
        boost::proto::is_extension<T >
 
3195
      >
 
3196
    >
 
3197
  >,
 
3198
  boost::proto::tag::minus,
 
3199
  field_basic<T,M> const &,
 
3200
  T const &
 
3201
>::type /* const */
 
3202
operator- (field_basic<T,M> const &left, T const &right)
 
3203
{
 
3204
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_basic<T,M> const &, T const &>()(left, right);
 
3205
}
 
3206
#endif // BOOST_VERSION
782
3207
template<class T, class M>
 
3208
#if BOOST_VERSION < 104601
783
3209
typename
784
3210
boost::proto::detail::enable_binary<
785
3211
  field_domain,
793
3219
operator- (const field_indirect<T,M>& l, const int& r)
794
3220
{
795
3221
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
796
 
    ::impl<const field_indirect<T,M>&,   const int&>() (l, r);
797
 
}
 
3222
    ::impl<const field_indirect<T,M>&, const int&>() (l, r);
 
3223
}
 
3224
#else // BOOST_VERSION >= 104601
 
3225
typename boost::proto::detail::enable_binary< 
 
3226
  field_domain,
 
3227
  field_domain::proto_grammar,
 
3228
  boost::mpl::and_<
 
3229
    boost::mpl::or_<is_field<field_indirect<T,M> >, is_field<int > >,
 
3230
    boost::mpl::not_<
 
3231
      boost::mpl::or_<
 
3232
        boost::proto::is_extension<field_indirect<T,M> >,
 
3233
        boost::proto::is_extension<int >
 
3234
      >
 
3235
    >
 
3236
  >,
 
3237
  boost::proto::tag::minus,
 
3238
  field_indirect<T,M> const &,
 
3239
  int const &
 
3240
>::type /* const */
 
3241
operator- (field_indirect<T,M> const &left, int const &right)
 
3242
{
 
3243
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect<T,M> const &, int const &>()(left, right);
 
3244
}
 
3245
#endif // BOOST_VERSION
798
3246
template<class T, class M>
 
3247
#if BOOST_VERSION < 104601
799
3248
typename
800
3249
boost::proto::detail::enable_binary<
801
3250
  field_domain,
809
3258
operator- (const field_indirect<T,M>& l, const T& r)
810
3259
{
811
3260
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
812
 
    ::impl<const field_indirect<T,M>&,   const T&>() (l, r);
813
 
}
 
3261
    ::impl<const field_indirect<T,M>&, const T&>() (l, r);
 
3262
}
 
3263
#else // BOOST_VERSION >= 104601
 
3264
typename boost::proto::detail::enable_binary< 
 
3265
  field_domain,
 
3266
  field_domain::proto_grammar,
 
3267
  boost::mpl::and_<
 
3268
    boost::mpl::or_<is_field<field_indirect<T,M> >, is_field<T > >,
 
3269
    boost::mpl::not_<
 
3270
      boost::mpl::or_<
 
3271
        boost::proto::is_extension<field_indirect<T,M> >,
 
3272
        boost::proto::is_extension<T >
 
3273
      >
 
3274
    >
 
3275
  >,
 
3276
  boost::proto::tag::minus,
 
3277
  field_indirect<T,M> const &,
 
3278
  T const &
 
3279
>::type /* const */
 
3280
operator- (field_indirect<T,M> const &left, T const &right)
 
3281
{
 
3282
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect<T,M> const &, T const &>()(left, right);
 
3283
}
 
3284
#endif // BOOST_VERSION
814
3285
template<class T, class M>
 
3286
#if BOOST_VERSION < 104601
815
3287
typename
816
3288
boost::proto::detail::enable_binary<
817
3289
  field_domain,
825
3297
operator- (const field_indirect_const<T,M>& l, const int& r)
826
3298
{
827
3299
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
828
 
    ::impl<const field_indirect_const<T,M>&,   const int&>() (l, r);
829
 
}
 
3300
    ::impl<const field_indirect_const<T,M>&, const int&>() (l, r);
 
3301
}
 
3302
#else // BOOST_VERSION >= 104601
 
3303
typename boost::proto::detail::enable_binary< 
 
3304
  field_domain,
 
3305
  field_domain::proto_grammar,
 
3306
  boost::mpl::and_<
 
3307
    boost::mpl::or_<is_field<field_indirect_const<T,M> >, is_field<int > >,
 
3308
    boost::mpl::not_<
 
3309
      boost::mpl::or_<
 
3310
        boost::proto::is_extension<field_indirect_const<T,M> >,
 
3311
        boost::proto::is_extension<int >
 
3312
      >
 
3313
    >
 
3314
  >,
 
3315
  boost::proto::tag::minus,
 
3316
  field_indirect_const<T,M> const &,
 
3317
  int const &
 
3318
>::type /* const */
 
3319
operator- (field_indirect_const<T,M> const &left, int const &right)
 
3320
{
 
3321
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect_const<T,M> const &, int const &>()(left, right);
 
3322
}
 
3323
#endif // BOOST_VERSION
830
3324
template<class T, class M>
 
3325
#if BOOST_VERSION < 104601
831
3326
typename
832
3327
boost::proto::detail::enable_binary<
833
3328
  field_domain,
841
3336
operator- (const field_indirect_const<T,M>& l, const T& r)
842
3337
{
843
3338
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
844
 
    ::impl<const field_indirect_const<T,M>&,   const T&>() (l, r);
845
 
}
 
3339
    ::impl<const field_indirect_const<T,M>&, const T&>() (l, r);
 
3340
}
 
3341
#else // BOOST_VERSION >= 104601
 
3342
typename boost::proto::detail::enable_binary< 
 
3343
  field_domain,
 
3344
  field_domain::proto_grammar,
 
3345
  boost::mpl::and_<
 
3346
    boost::mpl::or_<is_field<field_indirect_const<T,M> >, is_field<T > >,
 
3347
    boost::mpl::not_<
 
3348
      boost::mpl::or_<
 
3349
        boost::proto::is_extension<field_indirect_const<T,M> >,
 
3350
        boost::proto::is_extension<T >
 
3351
      >
 
3352
    >
 
3353
  >,
 
3354
  boost::proto::tag::minus,
 
3355
  field_indirect_const<T,M> const &,
 
3356
  T const &
 
3357
>::type /* const */
 
3358
operator- (field_indirect_const<T,M> const &left, T const &right)
 
3359
{
 
3360
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect_const<T,M> const &, T const &>()(left, right);
 
3361
}
 
3362
#endif // BOOST_VERSION
 
3363
template<class T, class M>
 
3364
#if BOOST_VERSION < 104601
 
3365
typename
 
3366
boost::proto::detail::enable_binary<
 
3367
  field_domain,
 
3368
  is_field<field_component<T,M> >,
 
3369
  field_component<T,M>,
 
3370
  is_field<int >,
 
3371
  int,
 
3372
  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
3373
    ::impl<const field_component<T,M>&,   const int&>::result_type const
 
3374
>::type
 
3375
operator- (const field_component<T,M>& l, const int& r)
 
3376
{
 
3377
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
3378
    ::impl<const field_component<T,M>&, const int&>() (l, r);
 
3379
}
 
3380
#else // BOOST_VERSION >= 104601
 
3381
typename boost::proto::detail::enable_binary< 
 
3382
  field_domain,
 
3383
  field_domain::proto_grammar,
 
3384
  boost::mpl::and_<
 
3385
    boost::mpl::or_<is_field<field_component<T,M> >, is_field<int > >,
 
3386
    boost::mpl::not_<
 
3387
      boost::mpl::or_<
 
3388
        boost::proto::is_extension<field_component<T,M> >,
 
3389
        boost::proto::is_extension<int >
 
3390
      >
 
3391
    >
 
3392
  >,
 
3393
  boost::proto::tag::minus,
 
3394
  field_component<T,M> const &,
 
3395
  int const &
 
3396
>::type /* const */
 
3397
operator- (field_component<T,M> const &left, int const &right)
 
3398
{
 
3399
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component<T,M> const &, int const &>()(left, right);
 
3400
}
 
3401
#endif // BOOST_VERSION
 
3402
template<class T, class M>
 
3403
#if BOOST_VERSION < 104601
 
3404
typename
 
3405
boost::proto::detail::enable_binary<
 
3406
  field_domain,
 
3407
  is_field<field_component<T,M> >,
 
3408
  field_component<T,M>,
 
3409
  is_field<T >,
 
3410
  T,
 
3411
  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
3412
    ::impl<const field_component<T,M>&,   const T&>::result_type const
 
3413
>::type
 
3414
operator- (const field_component<T,M>& l, const T& r)
 
3415
{
 
3416
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
3417
    ::impl<const field_component<T,M>&, const T&>() (l, r);
 
3418
}
 
3419
#else // BOOST_VERSION >= 104601
 
3420
typename boost::proto::detail::enable_binary< 
 
3421
  field_domain,
 
3422
  field_domain::proto_grammar,
 
3423
  boost::mpl::and_<
 
3424
    boost::mpl::or_<is_field<field_component<T,M> >, is_field<T > >,
 
3425
    boost::mpl::not_<
 
3426
      boost::mpl::or_<
 
3427
        boost::proto::is_extension<field_component<T,M> >,
 
3428
        boost::proto::is_extension<T >
 
3429
      >
 
3430
    >
 
3431
  >,
 
3432
  boost::proto::tag::minus,
 
3433
  field_component<T,M> const &,
 
3434
  T const &
 
3435
>::type /* const */
 
3436
operator- (field_component<T,M> const &left, T const &right)
 
3437
{
 
3438
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component<T,M> const &, T const &>()(left, right);
 
3439
}
 
3440
#endif // BOOST_VERSION
 
3441
template<class T, class M>
 
3442
#if BOOST_VERSION < 104601
 
3443
typename
 
3444
boost::proto::detail::enable_binary<
 
3445
  field_domain,
 
3446
  is_field<field_component_const<T,M> >,
 
3447
  field_component_const<T,M>,
 
3448
  is_field<int >,
 
3449
  int,
 
3450
  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
3451
    ::impl<const field_component_const<T,M>&,   const int&>::result_type const
 
3452
>::type
 
3453
operator- (const field_component_const<T,M>& l, const int& r)
 
3454
{
 
3455
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
3456
    ::impl<const field_component_const<T,M>&, const int&>() (l, r);
 
3457
}
 
3458
#else // BOOST_VERSION >= 104601
 
3459
typename boost::proto::detail::enable_binary< 
 
3460
  field_domain,
 
3461
  field_domain::proto_grammar,
 
3462
  boost::mpl::and_<
 
3463
    boost::mpl::or_<is_field<field_component_const<T,M> >, is_field<int > >,
 
3464
    boost::mpl::not_<
 
3465
      boost::mpl::or_<
 
3466
        boost::proto::is_extension<field_component_const<T,M> >,
 
3467
        boost::proto::is_extension<int >
 
3468
      >
 
3469
    >
 
3470
  >,
 
3471
  boost::proto::tag::minus,
 
3472
  field_component_const<T,M> const &,
 
3473
  int const &
 
3474
>::type /* const */
 
3475
operator- (field_component_const<T,M> const &left, int const &right)
 
3476
{
 
3477
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component_const<T,M> const &, int const &>()(left, right);
 
3478
}
 
3479
#endif // BOOST_VERSION
 
3480
template<class T, class M>
 
3481
#if BOOST_VERSION < 104601
 
3482
typename
 
3483
boost::proto::detail::enable_binary<
 
3484
  field_domain,
 
3485
  is_field<field_component_const<T,M> >,
 
3486
  field_component_const<T,M>,
 
3487
  is_field<T >,
 
3488
  T,
 
3489
  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
3490
    ::impl<const field_component_const<T,M>&,   const T&>::result_type const
 
3491
>::type
 
3492
operator- (const field_component_const<T,M>& l, const T& r)
 
3493
{
 
3494
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
3495
    ::impl<const field_component_const<T,M>&, const T&>() (l, r);
 
3496
}
 
3497
#else // BOOST_VERSION >= 104601
 
3498
typename boost::proto::detail::enable_binary< 
 
3499
  field_domain,
 
3500
  field_domain::proto_grammar,
 
3501
  boost::mpl::and_<
 
3502
    boost::mpl::or_<is_field<field_component_const<T,M> >, is_field<T > >,
 
3503
    boost::mpl::not_<
 
3504
      boost::mpl::or_<
 
3505
        boost::proto::is_extension<field_component_const<T,M> >,
 
3506
        boost::proto::is_extension<T >
 
3507
      >
 
3508
    >
 
3509
  >,
 
3510
  boost::proto::tag::minus,
 
3511
  field_component_const<T,M> const &,
 
3512
  T const &
 
3513
>::type /* const */
 
3514
operator- (field_component_const<T,M> const &left, T const &right)
 
3515
{
 
3516
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component_const<T,M> const &, T const &>()(left, right);
 
3517
}
 
3518
#endif // BOOST_VERSION
846
3519
template<class T1, class T2, class M>
 
3520
#if BOOST_VERSION < 104601
847
3521
typename
848
3522
boost::proto::detail::enable_binary<
849
3523
  field_domain,
857
3531
operator- (const field_basic<T1,M>& l, const field_basic<T2,M>& r)
858
3532
{
859
3533
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
860
 
    ::impl<const field_basic<T1,M>&,   const field_basic<T2,M>&>() (l, r);
861
 
}
 
3534
    ::impl<const field_basic<T1,M>&, const field_basic<T2,M>&>() (l, r);
 
3535
}
 
3536
#else // BOOST_VERSION >= 104601
 
3537
typename boost::proto::detail::enable_binary< 
 
3538
  field_domain,
 
3539
  field_domain::proto_grammar,
 
3540
  boost::mpl::and_<
 
3541
    boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_basic<T2,M> > >,
 
3542
    boost::mpl::not_<
 
3543
      boost::mpl::or_<
 
3544
        boost::proto::is_extension<field_basic<T1,M> >,
 
3545
        boost::proto::is_extension<field_basic<T2,M> >
 
3546
      >
 
3547
    >
 
3548
  >,
 
3549
  boost::proto::tag::minus,
 
3550
  field_basic<T1,M> const &,
 
3551
  field_basic<T2,M> const &
 
3552
>::type /* const */
 
3553
operator- (field_basic<T1,M> const &left, field_basic<T2,M> const &right)
 
3554
{
 
3555
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_basic<T1,M> const &, field_basic<T2,M> const &>()(left, right);
 
3556
}
 
3557
#endif // BOOST_VERSION
862
3558
template<class T1, class T2, class M>
 
3559
#if BOOST_VERSION < 104601
863
3560
typename
864
3561
boost::proto::detail::enable_binary<
865
3562
  field_domain,
873
3570
operator- (const field_basic<T1,M>& l, const field_indirect<T2,M>& r)
874
3571
{
875
3572
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
876
 
    ::impl<const field_basic<T1,M>&,   const field_indirect<T2,M>&>() (l, r);
877
 
}
 
3573
    ::impl<const field_basic<T1,M>&, const field_indirect<T2,M>&>() (l, r);
 
3574
}
 
3575
#else // BOOST_VERSION >= 104601
 
3576
typename boost::proto::detail::enable_binary< 
 
3577
  field_domain,
 
3578
  field_domain::proto_grammar,
 
3579
  boost::mpl::and_<
 
3580
    boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_indirect<T2,M> > >,
 
3581
    boost::mpl::not_<
 
3582
      boost::mpl::or_<
 
3583
        boost::proto::is_extension<field_basic<T1,M> >,
 
3584
        boost::proto::is_extension<field_indirect<T2,M> >
 
3585
      >
 
3586
    >
 
3587
  >,
 
3588
  boost::proto::tag::minus,
 
3589
  field_basic<T1,M> const &,
 
3590
  field_indirect<T2,M> const &
 
3591
>::type /* const */
 
3592
operator- (field_basic<T1,M> const &left, field_indirect<T2,M> const &right)
 
3593
{
 
3594
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_basic<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
 
3595
}
 
3596
#endif // BOOST_VERSION
878
3597
template<class T1, class T2, class M>
 
3598
#if BOOST_VERSION < 104601
879
3599
typename
880
3600
boost::proto::detail::enable_binary<
881
3601
  field_domain,
889
3609
operator- (const field_basic<T1,M>& l, const field_indirect_const<T2,M>& r)
890
3610
{
891
3611
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
892
 
    ::impl<const field_basic<T1,M>&,   const field_indirect_const<T2,M>&>() (l, r);
893
 
}
894
 
template<class T1, class T2, class M>
 
3612
    ::impl<const field_basic<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
 
3613
}
 
3614
#else // BOOST_VERSION >= 104601
 
3615
typename boost::proto::detail::enable_binary< 
 
3616
  field_domain,
 
3617
  field_domain::proto_grammar,
 
3618
  boost::mpl::and_<
 
3619
    boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_indirect_const<T2,M> > >,
 
3620
    boost::mpl::not_<
 
3621
      boost::mpl::or_<
 
3622
        boost::proto::is_extension<field_basic<T1,M> >,
 
3623
        boost::proto::is_extension<field_indirect_const<T2,M> >
 
3624
      >
 
3625
    >
 
3626
  >,
 
3627
  boost::proto::tag::minus,
 
3628
  field_basic<T1,M> const &,
 
3629
  field_indirect_const<T2,M> const &
 
3630
>::type /* const */
 
3631
operator- (field_basic<T1,M> const &left, field_indirect_const<T2,M> const &right)
 
3632
{
 
3633
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_basic<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
 
3634
}
 
3635
#endif // BOOST_VERSION
 
3636
template<class T1, class T2, class M>
 
3637
#if BOOST_VERSION < 104601
 
3638
typename
 
3639
boost::proto::detail::enable_binary<
 
3640
  field_domain,
 
3641
  is_field<field_basic<T1,M> >,
 
3642
  field_basic<T1,M>,
 
3643
  is_field<field_component<T2,M> >,
 
3644
  field_component<T2,M>,
 
3645
  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
3646
    ::impl<const field_basic<T1,M>&,   const field_component<T2,M>&>::result_type const
 
3647
>::type
 
3648
operator- (const field_basic<T1,M>& l, const field_component<T2,M>& r)
 
3649
{
 
3650
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
3651
    ::impl<const field_basic<T1,M>&, const field_component<T2,M>&>() (l, r);
 
3652
}
 
3653
#else // BOOST_VERSION >= 104601
 
3654
typename boost::proto::detail::enable_binary< 
 
3655
  field_domain,
 
3656
  field_domain::proto_grammar,
 
3657
  boost::mpl::and_<
 
3658
    boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_component<T2,M> > >,
 
3659
    boost::mpl::not_<
 
3660
      boost::mpl::or_<
 
3661
        boost::proto::is_extension<field_basic<T1,M> >,
 
3662
        boost::proto::is_extension<field_component<T2,M> >
 
3663
      >
 
3664
    >
 
3665
  >,
 
3666
  boost::proto::tag::minus,
 
3667
  field_basic<T1,M> const &,
 
3668
  field_component<T2,M> const &
 
3669
>::type /* const */
 
3670
operator- (field_basic<T1,M> const &left, field_component<T2,M> const &right)
 
3671
{
 
3672
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_basic<T1,M> const &, field_component<T2,M> const &>()(left, right);
 
3673
}
 
3674
#endif // BOOST_VERSION
 
3675
template<class T1, class T2, class M>
 
3676
#if BOOST_VERSION < 104601
 
3677
typename
 
3678
boost::proto::detail::enable_binary<
 
3679
  field_domain,
 
3680
  is_field<field_basic<T1,M> >,
 
3681
  field_basic<T1,M>,
 
3682
  is_field<field_component_const<T2,M> >,
 
3683
  field_component_const<T2,M>,
 
3684
  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
3685
    ::impl<const field_basic<T1,M>&,   const field_component_const<T2,M>&>::result_type const
 
3686
>::type
 
3687
operator- (const field_basic<T1,M>& l, const field_component_const<T2,M>& r)
 
3688
{
 
3689
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
3690
    ::impl<const field_basic<T1,M>&, const field_component_const<T2,M>&>() (l, r);
 
3691
}
 
3692
#else // BOOST_VERSION >= 104601
 
3693
typename boost::proto::detail::enable_binary< 
 
3694
  field_domain,
 
3695
  field_domain::proto_grammar,
 
3696
  boost::mpl::and_<
 
3697
    boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_component_const<T2,M> > >,
 
3698
    boost::mpl::not_<
 
3699
      boost::mpl::or_<
 
3700
        boost::proto::is_extension<field_basic<T1,M> >,
 
3701
        boost::proto::is_extension<field_component_const<T2,M> >
 
3702
      >
 
3703
    >
 
3704
  >,
 
3705
  boost::proto::tag::minus,
 
3706
  field_basic<T1,M> const &,
 
3707
  field_component_const<T2,M> const &
 
3708
>::type /* const */
 
3709
operator- (field_basic<T1,M> const &left, field_component_const<T2,M> const &right)
 
3710
{
 
3711
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_basic<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
 
3712
}
 
3713
#endif // BOOST_VERSION
 
3714
template<class T1, class T2, class M>
 
3715
#if BOOST_VERSION < 104601
895
3716
typename
896
3717
boost::proto::detail::enable_binary<
897
3718
  field_domain,
905
3726
operator- (const field_indirect<T1,M>& l, const field_basic<T2,M>& r)
906
3727
{
907
3728
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
908
 
    ::impl<const field_indirect<T1,M>&,   const field_basic<T2,M>&>() (l, r);
909
 
}
 
3729
    ::impl<const field_indirect<T1,M>&, const field_basic<T2,M>&>() (l, r);
 
3730
}
 
3731
#else // BOOST_VERSION >= 104601
 
3732
typename boost::proto::detail::enable_binary< 
 
3733
  field_domain,
 
3734
  field_domain::proto_grammar,
 
3735
  boost::mpl::and_<
 
3736
    boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_basic<T2,M> > >,
 
3737
    boost::mpl::not_<
 
3738
      boost::mpl::or_<
 
3739
        boost::proto::is_extension<field_indirect<T1,M> >,
 
3740
        boost::proto::is_extension<field_basic<T2,M> >
 
3741
      >
 
3742
    >
 
3743
  >,
 
3744
  boost::proto::tag::minus,
 
3745
  field_indirect<T1,M> const &,
 
3746
  field_basic<T2,M> const &
 
3747
>::type /* const */
 
3748
operator- (field_indirect<T1,M> const &left, field_basic<T2,M> const &right)
 
3749
{
 
3750
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect<T1,M> const &, field_basic<T2,M> const &>()(left, right);
 
3751
}
 
3752
#endif // BOOST_VERSION
910
3753
template<class T1, class T2, class M>
 
3754
#if BOOST_VERSION < 104601
911
3755
typename
912
3756
boost::proto::detail::enable_binary<
913
3757
  field_domain,
921
3765
operator- (const field_indirect<T1,M>& l, const field_indirect<T2,M>& r)
922
3766
{
923
3767
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
924
 
    ::impl<const field_indirect<T1,M>&,   const field_indirect<T2,M>&>() (l, r);
925
 
}
 
3768
    ::impl<const field_indirect<T1,M>&, const field_indirect<T2,M>&>() (l, r);
 
3769
}
 
3770
#else // BOOST_VERSION >= 104601
 
3771
typename boost::proto::detail::enable_binary< 
 
3772
  field_domain,
 
3773
  field_domain::proto_grammar,
 
3774
  boost::mpl::and_<
 
3775
    boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_indirect<T2,M> > >,
 
3776
    boost::mpl::not_<
 
3777
      boost::mpl::or_<
 
3778
        boost::proto::is_extension<field_indirect<T1,M> >,
 
3779
        boost::proto::is_extension<field_indirect<T2,M> >
 
3780
      >
 
3781
    >
 
3782
  >,
 
3783
  boost::proto::tag::minus,
 
3784
  field_indirect<T1,M> const &,
 
3785
  field_indirect<T2,M> const &
 
3786
>::type /* const */
 
3787
operator- (field_indirect<T1,M> const &left, field_indirect<T2,M> const &right)
 
3788
{
 
3789
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
 
3790
}
 
3791
#endif // BOOST_VERSION
926
3792
template<class T1, class T2, class M>
 
3793
#if BOOST_VERSION < 104601
927
3794
typename
928
3795
boost::proto::detail::enable_binary<
929
3796
  field_domain,
937
3804
operator- (const field_indirect<T1,M>& l, const field_indirect_const<T2,M>& r)
938
3805
{
939
3806
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
940
 
    ::impl<const field_indirect<T1,M>&,   const field_indirect_const<T2,M>&>() (l, r);
941
 
}
942
 
template<class T1, class T2, class M>
 
3807
    ::impl<const field_indirect<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
 
3808
}
 
3809
#else // BOOST_VERSION >= 104601
 
3810
typename boost::proto::detail::enable_binary< 
 
3811
  field_domain,
 
3812
  field_domain::proto_grammar,
 
3813
  boost::mpl::and_<
 
3814
    boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_indirect_const<T2,M> > >,
 
3815
    boost::mpl::not_<
 
3816
      boost::mpl::or_<
 
3817
        boost::proto::is_extension<field_indirect<T1,M> >,
 
3818
        boost::proto::is_extension<field_indirect_const<T2,M> >
 
3819
      >
 
3820
    >
 
3821
  >,
 
3822
  boost::proto::tag::minus,
 
3823
  field_indirect<T1,M> const &,
 
3824
  field_indirect_const<T2,M> const &
 
3825
>::type /* const */
 
3826
operator- (field_indirect<T1,M> const &left, field_indirect_const<T2,M> const &right)
 
3827
{
 
3828
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
 
3829
}
 
3830
#endif // BOOST_VERSION
 
3831
template<class T1, class T2, class M>
 
3832
#if BOOST_VERSION < 104601
 
3833
typename
 
3834
boost::proto::detail::enable_binary<
 
3835
  field_domain,
 
3836
  is_field<field_indirect<T1,M> >,
 
3837
  field_indirect<T1,M>,
 
3838
  is_field<field_component<T2,M> >,
 
3839
  field_component<T2,M>,
 
3840
  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
3841
    ::impl<const field_indirect<T1,M>&,   const field_component<T2,M>&>::result_type const
 
3842
>::type
 
3843
operator- (const field_indirect<T1,M>& l, const field_component<T2,M>& r)
 
3844
{
 
3845
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
3846
    ::impl<const field_indirect<T1,M>&, const field_component<T2,M>&>() (l, r);
 
3847
}
 
3848
#else // BOOST_VERSION >= 104601
 
3849
typename boost::proto::detail::enable_binary< 
 
3850
  field_domain,
 
3851
  field_domain::proto_grammar,
 
3852
  boost::mpl::and_<
 
3853
    boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_component<T2,M> > >,
 
3854
    boost::mpl::not_<
 
3855
      boost::mpl::or_<
 
3856
        boost::proto::is_extension<field_indirect<T1,M> >,
 
3857
        boost::proto::is_extension<field_component<T2,M> >
 
3858
      >
 
3859
    >
 
3860
  >,
 
3861
  boost::proto::tag::minus,
 
3862
  field_indirect<T1,M> const &,
 
3863
  field_component<T2,M> const &
 
3864
>::type /* const */
 
3865
operator- (field_indirect<T1,M> const &left, field_component<T2,M> const &right)
 
3866
{
 
3867
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect<T1,M> const &, field_component<T2,M> const &>()(left, right);
 
3868
}
 
3869
#endif // BOOST_VERSION
 
3870
template<class T1, class T2, class M>
 
3871
#if BOOST_VERSION < 104601
 
3872
typename
 
3873
boost::proto::detail::enable_binary<
 
3874
  field_domain,
 
3875
  is_field<field_indirect<T1,M> >,
 
3876
  field_indirect<T1,M>,
 
3877
  is_field<field_component_const<T2,M> >,
 
3878
  field_component_const<T2,M>,
 
3879
  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
3880
    ::impl<const field_indirect<T1,M>&,   const field_component_const<T2,M>&>::result_type const
 
3881
>::type
 
3882
operator- (const field_indirect<T1,M>& l, const field_component_const<T2,M>& r)
 
3883
{
 
3884
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
3885
    ::impl<const field_indirect<T1,M>&, const field_component_const<T2,M>&>() (l, r);
 
3886
}
 
3887
#else // BOOST_VERSION >= 104601
 
3888
typename boost::proto::detail::enable_binary< 
 
3889
  field_domain,
 
3890
  field_domain::proto_grammar,
 
3891
  boost::mpl::and_<
 
3892
    boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_component_const<T2,M> > >,
 
3893
    boost::mpl::not_<
 
3894
      boost::mpl::or_<
 
3895
        boost::proto::is_extension<field_indirect<T1,M> >,
 
3896
        boost::proto::is_extension<field_component_const<T2,M> >
 
3897
      >
 
3898
    >
 
3899
  >,
 
3900
  boost::proto::tag::minus,
 
3901
  field_indirect<T1,M> const &,
 
3902
  field_component_const<T2,M> const &
 
3903
>::type /* const */
 
3904
operator- (field_indirect<T1,M> const &left, field_component_const<T2,M> const &right)
 
3905
{
 
3906
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
 
3907
}
 
3908
#endif // BOOST_VERSION
 
3909
template<class T1, class T2, class M>
 
3910
#if BOOST_VERSION < 104601
943
3911
typename
944
3912
boost::proto::detail::enable_binary<
945
3913
  field_domain,
953
3921
operator- (const field_indirect_const<T1,M>& l, const field_basic<T2,M>& r)
954
3922
{
955
3923
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
956
 
    ::impl<const field_indirect_const<T1,M>&,   const field_basic<T2,M>&>() (l, r);
957
 
}
 
3924
    ::impl<const field_indirect_const<T1,M>&, const field_basic<T2,M>&>() (l, r);
 
3925
}
 
3926
#else // BOOST_VERSION >= 104601
 
3927
typename boost::proto::detail::enable_binary< 
 
3928
  field_domain,
 
3929
  field_domain::proto_grammar,
 
3930
  boost::mpl::and_<
 
3931
    boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_basic<T2,M> > >,
 
3932
    boost::mpl::not_<
 
3933
      boost::mpl::or_<
 
3934
        boost::proto::is_extension<field_indirect_const<T1,M> >,
 
3935
        boost::proto::is_extension<field_basic<T2,M> >
 
3936
      >
 
3937
    >
 
3938
  >,
 
3939
  boost::proto::tag::minus,
 
3940
  field_indirect_const<T1,M> const &,
 
3941
  field_basic<T2,M> const &
 
3942
>::type /* const */
 
3943
operator- (field_indirect_const<T1,M> const &left, field_basic<T2,M> const &right)
 
3944
{
 
3945
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect_const<T1,M> const &, field_basic<T2,M> const &>()(left, right);
 
3946
}
 
3947
#endif // BOOST_VERSION
958
3948
template<class T1, class T2, class M>
 
3949
#if BOOST_VERSION < 104601
959
3950
typename
960
3951
boost::proto::detail::enable_binary<
961
3952
  field_domain,
969
3960
operator- (const field_indirect_const<T1,M>& l, const field_indirect<T2,M>& r)
970
3961
{
971
3962
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
972
 
    ::impl<const field_indirect_const<T1,M>&,   const field_indirect<T2,M>&>() (l, r);
973
 
}
 
3963
    ::impl<const field_indirect_const<T1,M>&, const field_indirect<T2,M>&>() (l, r);
 
3964
}
 
3965
#else // BOOST_VERSION >= 104601
 
3966
typename boost::proto::detail::enable_binary< 
 
3967
  field_domain,
 
3968
  field_domain::proto_grammar,
 
3969
  boost::mpl::and_<
 
3970
    boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_indirect<T2,M> > >,
 
3971
    boost::mpl::not_<
 
3972
      boost::mpl::or_<
 
3973
        boost::proto::is_extension<field_indirect_const<T1,M> >,
 
3974
        boost::proto::is_extension<field_indirect<T2,M> >
 
3975
      >
 
3976
    >
 
3977
  >,
 
3978
  boost::proto::tag::minus,
 
3979
  field_indirect_const<T1,M> const &,
 
3980
  field_indirect<T2,M> const &
 
3981
>::type /* const */
 
3982
operator- (field_indirect_const<T1,M> const &left, field_indirect<T2,M> const &right)
 
3983
{
 
3984
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect_const<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
 
3985
}
 
3986
#endif // BOOST_VERSION
974
3987
template<class T1, class T2, class M>
 
3988
#if BOOST_VERSION < 104601
975
3989
typename
976
3990
boost::proto::detail::enable_binary<
977
3991
  field_domain,
985
3999
operator- (const field_indirect_const<T1,M>& l, const field_indirect_const<T2,M>& r)
986
4000
{
987
4001
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
988
 
    ::impl<const field_indirect_const<T1,M>&,   const field_indirect_const<T2,M>&>() (l, r);
989
 
}
 
4002
    ::impl<const field_indirect_const<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
 
4003
}
 
4004
#else // BOOST_VERSION >= 104601
 
4005
typename boost::proto::detail::enable_binary< 
 
4006
  field_domain,
 
4007
  field_domain::proto_grammar,
 
4008
  boost::mpl::and_<
 
4009
    boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_indirect_const<T2,M> > >,
 
4010
    boost::mpl::not_<
 
4011
      boost::mpl::or_<
 
4012
        boost::proto::is_extension<field_indirect_const<T1,M> >,
 
4013
        boost::proto::is_extension<field_indirect_const<T2,M> >
 
4014
      >
 
4015
    >
 
4016
  >,
 
4017
  boost::proto::tag::minus,
 
4018
  field_indirect_const<T1,M> const &,
 
4019
  field_indirect_const<T2,M> const &
 
4020
>::type /* const */
 
4021
operator- (field_indirect_const<T1,M> const &left, field_indirect_const<T2,M> const &right)
 
4022
{
 
4023
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect_const<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
 
4024
}
 
4025
#endif // BOOST_VERSION
 
4026
template<class T1, class T2, class M>
 
4027
#if BOOST_VERSION < 104601
 
4028
typename
 
4029
boost::proto::detail::enable_binary<
 
4030
  field_domain,
 
4031
  is_field<field_indirect_const<T1,M> >,
 
4032
  field_indirect_const<T1,M>,
 
4033
  is_field<field_component<T2,M> >,
 
4034
  field_component<T2,M>,
 
4035
  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4036
    ::impl<const field_indirect_const<T1,M>&,   const field_component<T2,M>&>::result_type const
 
4037
>::type
 
4038
operator- (const field_indirect_const<T1,M>& l, const field_component<T2,M>& r)
 
4039
{
 
4040
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4041
    ::impl<const field_indirect_const<T1,M>&, const field_component<T2,M>&>() (l, r);
 
4042
}
 
4043
#else // BOOST_VERSION >= 104601
 
4044
typename boost::proto::detail::enable_binary< 
 
4045
  field_domain,
 
4046
  field_domain::proto_grammar,
 
4047
  boost::mpl::and_<
 
4048
    boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_component<T2,M> > >,
 
4049
    boost::mpl::not_<
 
4050
      boost::mpl::or_<
 
4051
        boost::proto::is_extension<field_indirect_const<T1,M> >,
 
4052
        boost::proto::is_extension<field_component<T2,M> >
 
4053
      >
 
4054
    >
 
4055
  >,
 
4056
  boost::proto::tag::minus,
 
4057
  field_indirect_const<T1,M> const &,
 
4058
  field_component<T2,M> const &
 
4059
>::type /* const */
 
4060
operator- (field_indirect_const<T1,M> const &left, field_component<T2,M> const &right)
 
4061
{
 
4062
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect_const<T1,M> const &, field_component<T2,M> const &>()(left, right);
 
4063
}
 
4064
#endif // BOOST_VERSION
 
4065
template<class T1, class T2, class M>
 
4066
#if BOOST_VERSION < 104601
 
4067
typename
 
4068
boost::proto::detail::enable_binary<
 
4069
  field_domain,
 
4070
  is_field<field_indirect_const<T1,M> >,
 
4071
  field_indirect_const<T1,M>,
 
4072
  is_field<field_component_const<T2,M> >,
 
4073
  field_component_const<T2,M>,
 
4074
  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4075
    ::impl<const field_indirect_const<T1,M>&,   const field_component_const<T2,M>&>::result_type const
 
4076
>::type
 
4077
operator- (const field_indirect_const<T1,M>& l, const field_component_const<T2,M>& r)
 
4078
{
 
4079
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4080
    ::impl<const field_indirect_const<T1,M>&, const field_component_const<T2,M>&>() (l, r);
 
4081
}
 
4082
#else // BOOST_VERSION >= 104601
 
4083
typename boost::proto::detail::enable_binary< 
 
4084
  field_domain,
 
4085
  field_domain::proto_grammar,
 
4086
  boost::mpl::and_<
 
4087
    boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_component_const<T2,M> > >,
 
4088
    boost::mpl::not_<
 
4089
      boost::mpl::or_<
 
4090
        boost::proto::is_extension<field_indirect_const<T1,M> >,
 
4091
        boost::proto::is_extension<field_component_const<T2,M> >
 
4092
      >
 
4093
    >
 
4094
  >,
 
4095
  boost::proto::tag::minus,
 
4096
  field_indirect_const<T1,M> const &,
 
4097
  field_component_const<T2,M> const &
 
4098
>::type /* const */
 
4099
operator- (field_indirect_const<T1,M> const &left, field_component_const<T2,M> const &right)
 
4100
{
 
4101
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect_const<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
 
4102
}
 
4103
#endif // BOOST_VERSION
 
4104
template<class T1, class T2, class M>
 
4105
#if BOOST_VERSION < 104601
 
4106
typename
 
4107
boost::proto::detail::enable_binary<
 
4108
  field_domain,
 
4109
  is_field<field_component<T1,M> >,
 
4110
  field_component<T1,M>,
 
4111
  is_field<field_basic<T2,M> >,
 
4112
  field_basic<T2,M>,
 
4113
  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4114
    ::impl<const field_component<T1,M>&,   const field_basic<T2,M>&>::result_type const
 
4115
>::type
 
4116
operator- (const field_component<T1,M>& l, const field_basic<T2,M>& r)
 
4117
{
 
4118
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4119
    ::impl<const field_component<T1,M>&, const field_basic<T2,M>&>() (l, r);
 
4120
}
 
4121
#else // BOOST_VERSION >= 104601
 
4122
typename boost::proto::detail::enable_binary< 
 
4123
  field_domain,
 
4124
  field_domain::proto_grammar,
 
4125
  boost::mpl::and_<
 
4126
    boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_basic<T2,M> > >,
 
4127
    boost::mpl::not_<
 
4128
      boost::mpl::or_<
 
4129
        boost::proto::is_extension<field_component<T1,M> >,
 
4130
        boost::proto::is_extension<field_basic<T2,M> >
 
4131
      >
 
4132
    >
 
4133
  >,
 
4134
  boost::proto::tag::minus,
 
4135
  field_component<T1,M> const &,
 
4136
  field_basic<T2,M> const &
 
4137
>::type /* const */
 
4138
operator- (field_component<T1,M> const &left, field_basic<T2,M> const &right)
 
4139
{
 
4140
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component<T1,M> const &, field_basic<T2,M> const &>()(left, right);
 
4141
}
 
4142
#endif // BOOST_VERSION
 
4143
template<class T1, class T2, class M>
 
4144
#if BOOST_VERSION < 104601
 
4145
typename
 
4146
boost::proto::detail::enable_binary<
 
4147
  field_domain,
 
4148
  is_field<field_component<T1,M> >,
 
4149
  field_component<T1,M>,
 
4150
  is_field<field_indirect<T2,M> >,
 
4151
  field_indirect<T2,M>,
 
4152
  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4153
    ::impl<const field_component<T1,M>&,   const field_indirect<T2,M>&>::result_type const
 
4154
>::type
 
4155
operator- (const field_component<T1,M>& l, const field_indirect<T2,M>& r)
 
4156
{
 
4157
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4158
    ::impl<const field_component<T1,M>&, const field_indirect<T2,M>&>() (l, r);
 
4159
}
 
4160
#else // BOOST_VERSION >= 104601
 
4161
typename boost::proto::detail::enable_binary< 
 
4162
  field_domain,
 
4163
  field_domain::proto_grammar,
 
4164
  boost::mpl::and_<
 
4165
    boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_indirect<T2,M> > >,
 
4166
    boost::mpl::not_<
 
4167
      boost::mpl::or_<
 
4168
        boost::proto::is_extension<field_component<T1,M> >,
 
4169
        boost::proto::is_extension<field_indirect<T2,M> >
 
4170
      >
 
4171
    >
 
4172
  >,
 
4173
  boost::proto::tag::minus,
 
4174
  field_component<T1,M> const &,
 
4175
  field_indirect<T2,M> const &
 
4176
>::type /* const */
 
4177
operator- (field_component<T1,M> const &left, field_indirect<T2,M> const &right)
 
4178
{
 
4179
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
 
4180
}
 
4181
#endif // BOOST_VERSION
 
4182
template<class T1, class T2, class M>
 
4183
#if BOOST_VERSION < 104601
 
4184
typename
 
4185
boost::proto::detail::enable_binary<
 
4186
  field_domain,
 
4187
  is_field<field_component<T1,M> >,
 
4188
  field_component<T1,M>,
 
4189
  is_field<field_indirect_const<T2,M> >,
 
4190
  field_indirect_const<T2,M>,
 
4191
  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4192
    ::impl<const field_component<T1,M>&,   const field_indirect_const<T2,M>&>::result_type const
 
4193
>::type
 
4194
operator- (const field_component<T1,M>& l, const field_indirect_const<T2,M>& r)
 
4195
{
 
4196
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4197
    ::impl<const field_component<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
 
4198
}
 
4199
#else // BOOST_VERSION >= 104601
 
4200
typename boost::proto::detail::enable_binary< 
 
4201
  field_domain,
 
4202
  field_domain::proto_grammar,
 
4203
  boost::mpl::and_<
 
4204
    boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_indirect_const<T2,M> > >,
 
4205
    boost::mpl::not_<
 
4206
      boost::mpl::or_<
 
4207
        boost::proto::is_extension<field_component<T1,M> >,
 
4208
        boost::proto::is_extension<field_indirect_const<T2,M> >
 
4209
      >
 
4210
    >
 
4211
  >,
 
4212
  boost::proto::tag::minus,
 
4213
  field_component<T1,M> const &,
 
4214
  field_indirect_const<T2,M> const &
 
4215
>::type /* const */
 
4216
operator- (field_component<T1,M> const &left, field_indirect_const<T2,M> const &right)
 
4217
{
 
4218
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
 
4219
}
 
4220
#endif // BOOST_VERSION
 
4221
template<class T1, class T2, class M>
 
4222
#if BOOST_VERSION < 104601
 
4223
typename
 
4224
boost::proto::detail::enable_binary<
 
4225
  field_domain,
 
4226
  is_field<field_component<T1,M> >,
 
4227
  field_component<T1,M>,
 
4228
  is_field<field_component<T2,M> >,
 
4229
  field_component<T2,M>,
 
4230
  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4231
    ::impl<const field_component<T1,M>&,   const field_component<T2,M>&>::result_type const
 
4232
>::type
 
4233
operator- (const field_component<T1,M>& l, const field_component<T2,M>& r)
 
4234
{
 
4235
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4236
    ::impl<const field_component<T1,M>&, const field_component<T2,M>&>() (l, r);
 
4237
}
 
4238
#else // BOOST_VERSION >= 104601
 
4239
typename boost::proto::detail::enable_binary< 
 
4240
  field_domain,
 
4241
  field_domain::proto_grammar,
 
4242
  boost::mpl::and_<
 
4243
    boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_component<T2,M> > >,
 
4244
    boost::mpl::not_<
 
4245
      boost::mpl::or_<
 
4246
        boost::proto::is_extension<field_component<T1,M> >,
 
4247
        boost::proto::is_extension<field_component<T2,M> >
 
4248
      >
 
4249
    >
 
4250
  >,
 
4251
  boost::proto::tag::minus,
 
4252
  field_component<T1,M> const &,
 
4253
  field_component<T2,M> const &
 
4254
>::type /* const */
 
4255
operator- (field_component<T1,M> const &left, field_component<T2,M> const &right)
 
4256
{
 
4257
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component<T1,M> const &, field_component<T2,M> const &>()(left, right);
 
4258
}
 
4259
#endif // BOOST_VERSION
 
4260
template<class T1, class T2, class M>
 
4261
#if BOOST_VERSION < 104601
 
4262
typename
 
4263
boost::proto::detail::enable_binary<
 
4264
  field_domain,
 
4265
  is_field<field_component<T1,M> >,
 
4266
  field_component<T1,M>,
 
4267
  is_field<field_component_const<T2,M> >,
 
4268
  field_component_const<T2,M>,
 
4269
  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4270
    ::impl<const field_component<T1,M>&,   const field_component_const<T2,M>&>::result_type const
 
4271
>::type
 
4272
operator- (const field_component<T1,M>& l, const field_component_const<T2,M>& r)
 
4273
{
 
4274
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4275
    ::impl<const field_component<T1,M>&, const field_component_const<T2,M>&>() (l, r);
 
4276
}
 
4277
#else // BOOST_VERSION >= 104601
 
4278
typename boost::proto::detail::enable_binary< 
 
4279
  field_domain,
 
4280
  field_domain::proto_grammar,
 
4281
  boost::mpl::and_<
 
4282
    boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_component_const<T2,M> > >,
 
4283
    boost::mpl::not_<
 
4284
      boost::mpl::or_<
 
4285
        boost::proto::is_extension<field_component<T1,M> >,
 
4286
        boost::proto::is_extension<field_component_const<T2,M> >
 
4287
      >
 
4288
    >
 
4289
  >,
 
4290
  boost::proto::tag::minus,
 
4291
  field_component<T1,M> const &,
 
4292
  field_component_const<T2,M> const &
 
4293
>::type /* const */
 
4294
operator- (field_component<T1,M> const &left, field_component_const<T2,M> const &right)
 
4295
{
 
4296
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
 
4297
}
 
4298
#endif // BOOST_VERSION
 
4299
template<class T1, class T2, class M>
 
4300
#if BOOST_VERSION < 104601
 
4301
typename
 
4302
boost::proto::detail::enable_binary<
 
4303
  field_domain,
 
4304
  is_field<field_component_const<T1,M> >,
 
4305
  field_component_const<T1,M>,
 
4306
  is_field<field_basic<T2,M> >,
 
4307
  field_basic<T2,M>,
 
4308
  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4309
    ::impl<const field_component_const<T1,M>&,   const field_basic<T2,M>&>::result_type const
 
4310
>::type
 
4311
operator- (const field_component_const<T1,M>& l, const field_basic<T2,M>& r)
 
4312
{
 
4313
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4314
    ::impl<const field_component_const<T1,M>&, const field_basic<T2,M>&>() (l, r);
 
4315
}
 
4316
#else // BOOST_VERSION >= 104601
 
4317
typename boost::proto::detail::enable_binary< 
 
4318
  field_domain,
 
4319
  field_domain::proto_grammar,
 
4320
  boost::mpl::and_<
 
4321
    boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_basic<T2,M> > >,
 
4322
    boost::mpl::not_<
 
4323
      boost::mpl::or_<
 
4324
        boost::proto::is_extension<field_component_const<T1,M> >,
 
4325
        boost::proto::is_extension<field_basic<T2,M> >
 
4326
      >
 
4327
    >
 
4328
  >,
 
4329
  boost::proto::tag::minus,
 
4330
  field_component_const<T1,M> const &,
 
4331
  field_basic<T2,M> const &
 
4332
>::type /* const */
 
4333
operator- (field_component_const<T1,M> const &left, field_basic<T2,M> const &right)
 
4334
{
 
4335
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component_const<T1,M> const &, field_basic<T2,M> const &>()(left, right);
 
4336
}
 
4337
#endif // BOOST_VERSION
 
4338
template<class T1, class T2, class M>
 
4339
#if BOOST_VERSION < 104601
 
4340
typename
 
4341
boost::proto::detail::enable_binary<
 
4342
  field_domain,
 
4343
  is_field<field_component_const<T1,M> >,
 
4344
  field_component_const<T1,M>,
 
4345
  is_field<field_indirect<T2,M> >,
 
4346
  field_indirect<T2,M>,
 
4347
  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4348
    ::impl<const field_component_const<T1,M>&,   const field_indirect<T2,M>&>::result_type const
 
4349
>::type
 
4350
operator- (const field_component_const<T1,M>& l, const field_indirect<T2,M>& r)
 
4351
{
 
4352
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4353
    ::impl<const field_component_const<T1,M>&, const field_indirect<T2,M>&>() (l, r);
 
4354
}
 
4355
#else // BOOST_VERSION >= 104601
 
4356
typename boost::proto::detail::enable_binary< 
 
4357
  field_domain,
 
4358
  field_domain::proto_grammar,
 
4359
  boost::mpl::and_<
 
4360
    boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_indirect<T2,M> > >,
 
4361
    boost::mpl::not_<
 
4362
      boost::mpl::or_<
 
4363
        boost::proto::is_extension<field_component_const<T1,M> >,
 
4364
        boost::proto::is_extension<field_indirect<T2,M> >
 
4365
      >
 
4366
    >
 
4367
  >,
 
4368
  boost::proto::tag::minus,
 
4369
  field_component_const<T1,M> const &,
 
4370
  field_indirect<T2,M> const &
 
4371
>::type /* const */
 
4372
operator- (field_component_const<T1,M> const &left, field_indirect<T2,M> const &right)
 
4373
{
 
4374
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component_const<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
 
4375
}
 
4376
#endif // BOOST_VERSION
 
4377
template<class T1, class T2, class M>
 
4378
#if BOOST_VERSION < 104601
 
4379
typename
 
4380
boost::proto::detail::enable_binary<
 
4381
  field_domain,
 
4382
  is_field<field_component_const<T1,M> >,
 
4383
  field_component_const<T1,M>,
 
4384
  is_field<field_indirect_const<T2,M> >,
 
4385
  field_indirect_const<T2,M>,
 
4386
  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4387
    ::impl<const field_component_const<T1,M>&,   const field_indirect_const<T2,M>&>::result_type const
 
4388
>::type
 
4389
operator- (const field_component_const<T1,M>& l, const field_indirect_const<T2,M>& r)
 
4390
{
 
4391
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4392
    ::impl<const field_component_const<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
 
4393
}
 
4394
#else // BOOST_VERSION >= 104601
 
4395
typename boost::proto::detail::enable_binary< 
 
4396
  field_domain,
 
4397
  field_domain::proto_grammar,
 
4398
  boost::mpl::and_<
 
4399
    boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_indirect_const<T2,M> > >,
 
4400
    boost::mpl::not_<
 
4401
      boost::mpl::or_<
 
4402
        boost::proto::is_extension<field_component_const<T1,M> >,
 
4403
        boost::proto::is_extension<field_indirect_const<T2,M> >
 
4404
      >
 
4405
    >
 
4406
  >,
 
4407
  boost::proto::tag::minus,
 
4408
  field_component_const<T1,M> const &,
 
4409
  field_indirect_const<T2,M> const &
 
4410
>::type /* const */
 
4411
operator- (field_component_const<T1,M> const &left, field_indirect_const<T2,M> const &right)
 
4412
{
 
4413
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component_const<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
 
4414
}
 
4415
#endif // BOOST_VERSION
 
4416
template<class T1, class T2, class M>
 
4417
#if BOOST_VERSION < 104601
 
4418
typename
 
4419
boost::proto::detail::enable_binary<
 
4420
  field_domain,
 
4421
  is_field<field_component_const<T1,M> >,
 
4422
  field_component_const<T1,M>,
 
4423
  is_field<field_component<T2,M> >,
 
4424
  field_component<T2,M>,
 
4425
  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4426
    ::impl<const field_component_const<T1,M>&,   const field_component<T2,M>&>::result_type const
 
4427
>::type
 
4428
operator- (const field_component_const<T1,M>& l, const field_component<T2,M>& r)
 
4429
{
 
4430
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4431
    ::impl<const field_component_const<T1,M>&, const field_component<T2,M>&>() (l, r);
 
4432
}
 
4433
#else // BOOST_VERSION >= 104601
 
4434
typename boost::proto::detail::enable_binary< 
 
4435
  field_domain,
 
4436
  field_domain::proto_grammar,
 
4437
  boost::mpl::and_<
 
4438
    boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_component<T2,M> > >,
 
4439
    boost::mpl::not_<
 
4440
      boost::mpl::or_<
 
4441
        boost::proto::is_extension<field_component_const<T1,M> >,
 
4442
        boost::proto::is_extension<field_component<T2,M> >
 
4443
      >
 
4444
    >
 
4445
  >,
 
4446
  boost::proto::tag::minus,
 
4447
  field_component_const<T1,M> const &,
 
4448
  field_component<T2,M> const &
 
4449
>::type /* const */
 
4450
operator- (field_component_const<T1,M> const &left, field_component<T2,M> const &right)
 
4451
{
 
4452
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component_const<T1,M> const &, field_component<T2,M> const &>()(left, right);
 
4453
}
 
4454
#endif // BOOST_VERSION
 
4455
template<class T1, class T2, class M>
 
4456
#if BOOST_VERSION < 104601
 
4457
typename
 
4458
boost::proto::detail::enable_binary<
 
4459
  field_domain,
 
4460
  is_field<field_component_const<T1,M> >,
 
4461
  field_component_const<T1,M>,
 
4462
  is_field<field_component_const<T2,M> >,
 
4463
  field_component_const<T2,M>,
 
4464
  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4465
    ::impl<const field_component_const<T1,M>&,   const field_component_const<T2,M>&>::result_type const
 
4466
>::type
 
4467
operator- (const field_component_const<T1,M>& l, const field_component_const<T2,M>& r)
 
4468
{
 
4469
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4470
    ::impl<const field_component_const<T1,M>&, const field_component_const<T2,M>&>() (l, r);
 
4471
}
 
4472
#else // BOOST_VERSION >= 104601
 
4473
typename boost::proto::detail::enable_binary< 
 
4474
  field_domain,
 
4475
  field_domain::proto_grammar,
 
4476
  boost::mpl::and_<
 
4477
    boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_component_const<T2,M> > >,
 
4478
    boost::mpl::not_<
 
4479
      boost::mpl::or_<
 
4480
        boost::proto::is_extension<field_component_const<T1,M> >,
 
4481
        boost::proto::is_extension<field_component_const<T2,M> >
 
4482
      >
 
4483
    >
 
4484
  >,
 
4485
  boost::proto::tag::minus,
 
4486
  field_component_const<T1,M> const &,
 
4487
  field_component_const<T2,M> const &
 
4488
>::type /* const */
 
4489
operator- (field_component_const<T1,M> const &left, field_component_const<T2,M> const &right)
 
4490
{
 
4491
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component_const<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
 
4492
}
 
4493
#endif // BOOST_VERSION
990
4494
template<class Expr>
 
4495
#if BOOST_VERSION < 104601
991
4496
typename
992
4497
boost::proto::detail::enable_binary<
993
4498
  field_domain,
1001
4506
operator- (const int& l, const field_expr<Expr>& r)
1002
4507
{
1003
4508
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
1004
 
    ::impl<const int&,   const field_expr<Expr>&>() (l, r);
1005
 
}
 
4509
    ::impl<const int&, const field_expr<Expr>&>() (l, r);
 
4510
}
 
4511
#else // BOOST_VERSION >= 104601
 
4512
typename boost::proto::detail::enable_binary< 
 
4513
  field_domain,
 
4514
  field_domain::proto_grammar,
 
4515
  boost::mpl::and_<
 
4516
    boost::mpl::or_<is_field<int >, is_field<field_expr<Expr> > >,
 
4517
    boost::mpl::not_<
 
4518
      boost::mpl::or_<
 
4519
        boost::proto::is_extension<int >,
 
4520
        boost::proto::is_extension<field_expr<Expr> >
 
4521
      >
 
4522
    >
 
4523
  >,
 
4524
  boost::proto::tag::minus,
 
4525
  int const &,
 
4526
  field_expr<Expr> const &
 
4527
>::type /* const */
 
4528
operator- (int const &left, field_expr<Expr> const &right)
 
4529
{
 
4530
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, int const &, field_expr<Expr> const &>()(left, right);
 
4531
}
 
4532
#endif // BOOST_VERSION
1006
4533
template<class Expr>
 
4534
#if BOOST_VERSION < 104601
1007
4535
typename
1008
4536
boost::proto::detail::enable_binary<
1009
4537
  field_domain,
1017
4545
operator- (const field_expr<Expr>& l, const int& r)
1018
4546
{
1019
4547
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
1020
 
    ::impl<const field_expr<Expr>&,   const int&>() (l, r);
1021
 
}
 
4548
    ::impl<const field_expr<Expr>&, const int&>() (l, r);
 
4549
}
 
4550
#else // BOOST_VERSION >= 104601
 
4551
typename boost::proto::detail::enable_binary< 
 
4552
  field_domain,
 
4553
  field_domain::proto_grammar,
 
4554
  boost::mpl::and_<
 
4555
    boost::mpl::or_<is_field<field_expr<Expr> >, is_field<int > >,
 
4556
    boost::mpl::not_<
 
4557
      boost::mpl::or_<
 
4558
        boost::proto::is_extension<field_expr<Expr> >,
 
4559
        boost::proto::is_extension<int >
 
4560
      >
 
4561
    >
 
4562
  >,
 
4563
  boost::proto::tag::minus,
 
4564
  field_expr<Expr> const &,
 
4565
  int const &
 
4566
>::type /* const */
 
4567
operator- (field_expr<Expr> const &left, int const &right)
 
4568
{
 
4569
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_expr<Expr> const &, int const &>()(left, right);
 
4570
}
 
4571
#endif // BOOST_VERSION
1022
4572
template<class T, class Expr>
 
4573
#if BOOST_VERSION < 104601
1023
4574
typename
1024
4575
boost::proto::detail::enable_binary<
1025
4576
  field_domain,
1033
4584
operator- (const T& l, const field_expr<Expr>& r)
1034
4585
{
1035
4586
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
1036
 
    ::impl<const T&,   const field_expr<Expr>&>() (l, r);
1037
 
}
 
4587
    ::impl<const T&, const field_expr<Expr>&>() (l, r);
 
4588
}
 
4589
#else // BOOST_VERSION >= 104601
 
4590
typename boost::proto::detail::enable_binary< 
 
4591
  field_domain,
 
4592
  field_domain::proto_grammar,
 
4593
  boost::mpl::and_<
 
4594
    boost::mpl::or_<is_field<T >, is_field<field_expr<Expr> > >,
 
4595
    boost::mpl::not_<
 
4596
      boost::mpl::or_<
 
4597
        boost::proto::is_extension<T >,
 
4598
        boost::proto::is_extension<field_expr<Expr> >
 
4599
      >
 
4600
    >
 
4601
  >,
 
4602
  boost::proto::tag::minus,
 
4603
  T const &,
 
4604
  field_expr<Expr> const &
 
4605
>::type /* const */
 
4606
operator- (T const &left, field_expr<Expr> const &right)
 
4607
{
 
4608
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, T const &, field_expr<Expr> const &>()(left, right);
 
4609
}
 
4610
#endif // BOOST_VERSION
1038
4611
template<class T, class Expr>
 
4612
#if BOOST_VERSION < 104601
1039
4613
typename
1040
4614
boost::proto::detail::enable_binary<
1041
4615
  field_domain,
1049
4623
operator- (const field_expr<Expr>& l, const T& r)
1050
4624
{
1051
4625
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
1052
 
    ::impl<const field_expr<Expr>&,   const T&>() (l, r);
1053
 
}
 
4626
    ::impl<const field_expr<Expr>&, const T&>() (l, r);
 
4627
}
 
4628
#else // BOOST_VERSION >= 104601
 
4629
typename boost::proto::detail::enable_binary< 
 
4630
  field_domain,
 
4631
  field_domain::proto_grammar,
 
4632
  boost::mpl::and_<
 
4633
    boost::mpl::or_<is_field<field_expr<Expr> >, is_field<T > >,
 
4634
    boost::mpl::not_<
 
4635
      boost::mpl::or_<
 
4636
        boost::proto::is_extension<field_expr<Expr> >,
 
4637
        boost::proto::is_extension<T >
 
4638
      >
 
4639
    >
 
4640
  >,
 
4641
  boost::proto::tag::minus,
 
4642
  field_expr<Expr> const &,
 
4643
  T const &
 
4644
>::type /* const */
 
4645
operator- (field_expr<Expr> const &left, T const &right)
 
4646
{
 
4647
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_expr<Expr> const &, T const &>()(left, right);
 
4648
}
 
4649
#endif // BOOST_VERSION
1054
4650
template<class T, class M, class Expr>
 
4651
#if BOOST_VERSION < 104601
1055
4652
typename
1056
4653
boost::proto::detail::enable_binary<
1057
4654
  field_domain,
1065
4662
operator- (const field_basic<T,M>& l, const field_expr<Expr>& r)
1066
4663
{
1067
4664
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
1068
 
    ::impl<const field_basic<T,M>&,   const field_expr<Expr>&>() (l, r);
1069
 
}
 
4665
    ::impl<const field_basic<T,M>&, const field_expr<Expr>&>() (l, r);
 
4666
}
 
4667
#else // BOOST_VERSION >= 104601
 
4668
typename boost::proto::detail::enable_binary< 
 
4669
  field_domain,
 
4670
  field_domain::proto_grammar,
 
4671
  boost::mpl::and_<
 
4672
    boost::mpl::or_<is_field<field_basic<T,M> >, is_field<field_expr<Expr> > >,
 
4673
    boost::mpl::not_<
 
4674
      boost::mpl::or_<
 
4675
        boost::proto::is_extension<field_basic<T,M> >,
 
4676
        boost::proto::is_extension<field_expr<Expr> >
 
4677
      >
 
4678
    >
 
4679
  >,
 
4680
  boost::proto::tag::minus,
 
4681
  field_basic<T,M> const &,
 
4682
  field_expr<Expr> const &
 
4683
>::type /* const */
 
4684
operator- (field_basic<T,M> const &left, field_expr<Expr> const &right)
 
4685
{
 
4686
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_basic<T,M> const &, field_expr<Expr> const &>()(left, right);
 
4687
}
 
4688
#endif // BOOST_VERSION
1070
4689
template<class T, class M, class Expr>
 
4690
#if BOOST_VERSION < 104601
1071
4691
typename
1072
4692
boost::proto::detail::enable_binary<
1073
4693
  field_domain,
1081
4701
operator- (const field_expr<Expr>& l, const field_basic<T,M>& r)
1082
4702
{
1083
4703
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
1084
 
    ::impl<const field_expr<Expr>&,   const field_basic<T,M>&>() (l, r);
1085
 
}
 
4704
    ::impl<const field_expr<Expr>&, const field_basic<T,M>&>() (l, r);
 
4705
}
 
4706
#else // BOOST_VERSION >= 104601
 
4707
typename boost::proto::detail::enable_binary< 
 
4708
  field_domain,
 
4709
  field_domain::proto_grammar,
 
4710
  boost::mpl::and_<
 
4711
    boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_basic<T,M> > >,
 
4712
    boost::mpl::not_<
 
4713
      boost::mpl::or_<
 
4714
        boost::proto::is_extension<field_expr<Expr> >,
 
4715
        boost::proto::is_extension<field_basic<T,M> >
 
4716
      >
 
4717
    >
 
4718
  >,
 
4719
  boost::proto::tag::minus,
 
4720
  field_expr<Expr> const &,
 
4721
  field_basic<T,M> const &
 
4722
>::type /* const */
 
4723
operator- (field_expr<Expr> const &left, field_basic<T,M> const &right)
 
4724
{
 
4725
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_expr<Expr> const &, field_basic<T,M> const &>()(left, right);
 
4726
}
 
4727
#endif // BOOST_VERSION
1086
4728
template<class T, class M, class Expr>
 
4729
#if BOOST_VERSION < 104601
1087
4730
typename
1088
4731
boost::proto::detail::enable_binary<
1089
4732
  field_domain,
1097
4740
operator- (const field_indirect<T,M>& l, const field_expr<Expr>& r)
1098
4741
{
1099
4742
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
1100
 
    ::impl<const field_indirect<T,M>&,   const field_expr<Expr>&>() (l, r);
1101
 
}
 
4743
    ::impl<const field_indirect<T,M>&, const field_expr<Expr>&>() (l, r);
 
4744
}
 
4745
#else // BOOST_VERSION >= 104601
 
4746
typename boost::proto::detail::enable_binary< 
 
4747
  field_domain,
 
4748
  field_domain::proto_grammar,
 
4749
  boost::mpl::and_<
 
4750
    boost::mpl::or_<is_field<field_indirect<T,M> >, is_field<field_expr<Expr> > >,
 
4751
    boost::mpl::not_<
 
4752
      boost::mpl::or_<
 
4753
        boost::proto::is_extension<field_indirect<T,M> >,
 
4754
        boost::proto::is_extension<field_expr<Expr> >
 
4755
      >
 
4756
    >
 
4757
  >,
 
4758
  boost::proto::tag::minus,
 
4759
  field_indirect<T,M> const &,
 
4760
  field_expr<Expr> const &
 
4761
>::type /* const */
 
4762
operator- (field_indirect<T,M> const &left, field_expr<Expr> const &right)
 
4763
{
 
4764
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect<T,M> const &, field_expr<Expr> const &>()(left, right);
 
4765
}
 
4766
#endif // BOOST_VERSION
1102
4767
template<class T, class M, class Expr>
 
4768
#if BOOST_VERSION < 104601
1103
4769
typename
1104
4770
boost::proto::detail::enable_binary<
1105
4771
  field_domain,
1113
4779
operator- (const field_expr<Expr>& l, const field_indirect<T,M>& r)
1114
4780
{
1115
4781
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
1116
 
    ::impl<const field_expr<Expr>&,   const field_indirect<T,M>&>() (l, r);
1117
 
}
 
4782
    ::impl<const field_expr<Expr>&, const field_indirect<T,M>&>() (l, r);
 
4783
}
 
4784
#else // BOOST_VERSION >= 104601
 
4785
typename boost::proto::detail::enable_binary< 
 
4786
  field_domain,
 
4787
  field_domain::proto_grammar,
 
4788
  boost::mpl::and_<
 
4789
    boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_indirect<T,M> > >,
 
4790
    boost::mpl::not_<
 
4791
      boost::mpl::or_<
 
4792
        boost::proto::is_extension<field_expr<Expr> >,
 
4793
        boost::proto::is_extension<field_indirect<T,M> >
 
4794
      >
 
4795
    >
 
4796
  >,
 
4797
  boost::proto::tag::minus,
 
4798
  field_expr<Expr> const &,
 
4799
  field_indirect<T,M> const &
 
4800
>::type /* const */
 
4801
operator- (field_expr<Expr> const &left, field_indirect<T,M> const &right)
 
4802
{
 
4803
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_expr<Expr> const &, field_indirect<T,M> const &>()(left, right);
 
4804
}
 
4805
#endif // BOOST_VERSION
1118
4806
template<class T, class M, class Expr>
 
4807
#if BOOST_VERSION < 104601
1119
4808
typename
1120
4809
boost::proto::detail::enable_binary<
1121
4810
  field_domain,
1129
4818
operator- (const field_indirect_const<T,M>& l, const field_expr<Expr>& r)
1130
4819
{
1131
4820
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
1132
 
    ::impl<const field_indirect_const<T,M>&,   const field_expr<Expr>&>() (l, r);
1133
 
}
 
4821
    ::impl<const field_indirect_const<T,M>&, const field_expr<Expr>&>() (l, r);
 
4822
}
 
4823
#else // BOOST_VERSION >= 104601
 
4824
typename boost::proto::detail::enable_binary< 
 
4825
  field_domain,
 
4826
  field_domain::proto_grammar,
 
4827
  boost::mpl::and_<
 
4828
    boost::mpl::or_<is_field<field_indirect_const<T,M> >, is_field<field_expr<Expr> > >,
 
4829
    boost::mpl::not_<
 
4830
      boost::mpl::or_<
 
4831
        boost::proto::is_extension<field_indirect_const<T,M> >,
 
4832
        boost::proto::is_extension<field_expr<Expr> >
 
4833
      >
 
4834
    >
 
4835
  >,
 
4836
  boost::proto::tag::minus,
 
4837
  field_indirect_const<T,M> const &,
 
4838
  field_expr<Expr> const &
 
4839
>::type /* const */
 
4840
operator- (field_indirect_const<T,M> const &left, field_expr<Expr> const &right)
 
4841
{
 
4842
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect_const<T,M> const &, field_expr<Expr> const &>()(left, right);
 
4843
}
 
4844
#endif // BOOST_VERSION
1134
4845
template<class T, class M, class Expr>
 
4846
#if BOOST_VERSION < 104601
1135
4847
typename
1136
4848
boost::proto::detail::enable_binary<
1137
4849
  field_domain,
1145
4857
operator- (const field_expr<Expr>& l, const field_indirect_const<T,M>& r)
1146
4858
{
1147
4859
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
1148
 
    ::impl<const field_expr<Expr>&,   const field_indirect_const<T,M>&>() (l, r);
1149
 
}
 
4860
    ::impl<const field_expr<Expr>&, const field_indirect_const<T,M>&>() (l, r);
 
4861
}
 
4862
#else // BOOST_VERSION >= 104601
 
4863
typename boost::proto::detail::enable_binary< 
 
4864
  field_domain,
 
4865
  field_domain::proto_grammar,
 
4866
  boost::mpl::and_<
 
4867
    boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_indirect_const<T,M> > >,
 
4868
    boost::mpl::not_<
 
4869
      boost::mpl::or_<
 
4870
        boost::proto::is_extension<field_expr<Expr> >,
 
4871
        boost::proto::is_extension<field_indirect_const<T,M> >
 
4872
      >
 
4873
    >
 
4874
  >,
 
4875
  boost::proto::tag::minus,
 
4876
  field_expr<Expr> const &,
 
4877
  field_indirect_const<T,M> const &
 
4878
>::type /* const */
 
4879
operator- (field_expr<Expr> const &left, field_indirect_const<T,M> const &right)
 
4880
{
 
4881
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_expr<Expr> const &, field_indirect_const<T,M> const &>()(left, right);
 
4882
}
 
4883
#endif // BOOST_VERSION
 
4884
template<class T, class M, class Expr>
 
4885
#if BOOST_VERSION < 104601
 
4886
typename
 
4887
boost::proto::detail::enable_binary<
 
4888
  field_domain,
 
4889
  is_field<field_component<T,M> >,
 
4890
  field_component<T,M>,
 
4891
  is_field<field_expr<Expr> >,
 
4892
  field_expr<Expr>,
 
4893
  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4894
    ::impl<const field_component<T,M>&,   const field_expr<Expr>&>::result_type const
 
4895
>::type
 
4896
operator- (const field_component<T,M>& l, const field_expr<Expr>& r)
 
4897
{
 
4898
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4899
    ::impl<const field_component<T,M>&, const field_expr<Expr>&>() (l, r);
 
4900
}
 
4901
#else // BOOST_VERSION >= 104601
 
4902
typename boost::proto::detail::enable_binary< 
 
4903
  field_domain,
 
4904
  field_domain::proto_grammar,
 
4905
  boost::mpl::and_<
 
4906
    boost::mpl::or_<is_field<field_component<T,M> >, is_field<field_expr<Expr> > >,
 
4907
    boost::mpl::not_<
 
4908
      boost::mpl::or_<
 
4909
        boost::proto::is_extension<field_component<T,M> >,
 
4910
        boost::proto::is_extension<field_expr<Expr> >
 
4911
      >
 
4912
    >
 
4913
  >,
 
4914
  boost::proto::tag::minus,
 
4915
  field_component<T,M> const &,
 
4916
  field_expr<Expr> const &
 
4917
>::type /* const */
 
4918
operator- (field_component<T,M> const &left, field_expr<Expr> const &right)
 
4919
{
 
4920
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component<T,M> const &, field_expr<Expr> const &>()(left, right);
 
4921
}
 
4922
#endif // BOOST_VERSION
 
4923
template<class T, class M, class Expr>
 
4924
#if BOOST_VERSION < 104601
 
4925
typename
 
4926
boost::proto::detail::enable_binary<
 
4927
  field_domain,
 
4928
  is_field<field_expr<Expr> >,
 
4929
  field_expr<Expr>,
 
4930
  is_field<field_component<T,M> >,
 
4931
  field_component<T,M>,
 
4932
  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4933
    ::impl<const field_expr<Expr>&,   const field_component<T,M>&>::result_type const
 
4934
>::type
 
4935
operator- (const field_expr<Expr>& l, const field_component<T,M>& r)
 
4936
{
 
4937
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4938
    ::impl<const field_expr<Expr>&, const field_component<T,M>&>() (l, r);
 
4939
}
 
4940
#else // BOOST_VERSION >= 104601
 
4941
typename boost::proto::detail::enable_binary< 
 
4942
  field_domain,
 
4943
  field_domain::proto_grammar,
 
4944
  boost::mpl::and_<
 
4945
    boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_component<T,M> > >,
 
4946
    boost::mpl::not_<
 
4947
      boost::mpl::or_<
 
4948
        boost::proto::is_extension<field_expr<Expr> >,
 
4949
        boost::proto::is_extension<field_component<T,M> >
 
4950
      >
 
4951
    >
 
4952
  >,
 
4953
  boost::proto::tag::minus,
 
4954
  field_expr<Expr> const &,
 
4955
  field_component<T,M> const &
 
4956
>::type /* const */
 
4957
operator- (field_expr<Expr> const &left, field_component<T,M> const &right)
 
4958
{
 
4959
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_expr<Expr> const &, field_component<T,M> const &>()(left, right);
 
4960
}
 
4961
#endif // BOOST_VERSION
 
4962
template<class T, class M, class Expr>
 
4963
#if BOOST_VERSION < 104601
 
4964
typename
 
4965
boost::proto::detail::enable_binary<
 
4966
  field_domain,
 
4967
  is_field<field_component_const<T,M> >,
 
4968
  field_component_const<T,M>,
 
4969
  is_field<field_expr<Expr> >,
 
4970
  field_expr<Expr>,
 
4971
  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4972
    ::impl<const field_component_const<T,M>&,   const field_expr<Expr>&>::result_type const
 
4973
>::type
 
4974
operator- (const field_component_const<T,M>& l, const field_expr<Expr>& r)
 
4975
{
 
4976
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
4977
    ::impl<const field_component_const<T,M>&, const field_expr<Expr>&>() (l, r);
 
4978
}
 
4979
#else // BOOST_VERSION >= 104601
 
4980
typename boost::proto::detail::enable_binary< 
 
4981
  field_domain,
 
4982
  field_domain::proto_grammar,
 
4983
  boost::mpl::and_<
 
4984
    boost::mpl::or_<is_field<field_component_const<T,M> >, is_field<field_expr<Expr> > >,
 
4985
    boost::mpl::not_<
 
4986
      boost::mpl::or_<
 
4987
        boost::proto::is_extension<field_component_const<T,M> >,
 
4988
        boost::proto::is_extension<field_expr<Expr> >
 
4989
      >
 
4990
    >
 
4991
  >,
 
4992
  boost::proto::tag::minus,
 
4993
  field_component_const<T,M> const &,
 
4994
  field_expr<Expr> const &
 
4995
>::type /* const */
 
4996
operator- (field_component_const<T,M> const &left, field_expr<Expr> const &right)
 
4997
{
 
4998
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component_const<T,M> const &, field_expr<Expr> const &>()(left, right);
 
4999
}
 
5000
#endif // BOOST_VERSION
 
5001
template<class T, class M, class Expr>
 
5002
#if BOOST_VERSION < 104601
 
5003
typename
 
5004
boost::proto::detail::enable_binary<
 
5005
  field_domain,
 
5006
  is_field<field_expr<Expr> >,
 
5007
  field_expr<Expr>,
 
5008
  is_field<field_component_const<T,M> >,
 
5009
  field_component_const<T,M>,
 
5010
  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
5011
    ::impl<const field_expr<Expr>&,   const field_component_const<T,M>&>::result_type const
 
5012
>::type
 
5013
operator- (const field_expr<Expr>& l, const field_component_const<T,M>& r)
 
5014
{
 
5015
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
 
5016
    ::impl<const field_expr<Expr>&, const field_component_const<T,M>&>() (l, r);
 
5017
}
 
5018
#else // BOOST_VERSION >= 104601
 
5019
typename boost::proto::detail::enable_binary< 
 
5020
  field_domain,
 
5021
  field_domain::proto_grammar,
 
5022
  boost::mpl::and_<
 
5023
    boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_component_const<T,M> > >,
 
5024
    boost::mpl::not_<
 
5025
      boost::mpl::or_<
 
5026
        boost::proto::is_extension<field_expr<Expr> >,
 
5027
        boost::proto::is_extension<field_component_const<T,M> >
 
5028
      >
 
5029
    >
 
5030
  >,
 
5031
  boost::proto::tag::minus,
 
5032
  field_expr<Expr> const &,
 
5033
  field_component_const<T,M> const &
 
5034
>::type /* const */
 
5035
operator- (field_expr<Expr> const &left, field_component_const<T,M> const &right)
 
5036
{
 
5037
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_expr<Expr> const &, field_component_const<T,M> const &>()(left, right);
 
5038
}
 
5039
#endif // BOOST_VERSION
1150
5040
template<class Expr1, class Expr2>
 
5041
#if BOOST_VERSION < 104601
1151
5042
typename
1152
5043
boost::proto::detail::enable_binary<
1153
5044
  field_domain,
1161
5052
operator- (const field_expr<Expr1>& l, const field_expr<Expr2>& r)
1162
5053
{
1163
5054
  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
1164
 
    ::impl<const field_expr<Expr1>&,   const field_expr<Expr2>&>() (l, r);
1165
 
}
 
5055
    ::impl<const field_expr<Expr1>&, const field_expr<Expr2>&>() (l, r);
 
5056
}
 
5057
#else // BOOST_VERSION >= 104601
 
5058
typename boost::proto::detail::enable_binary< 
 
5059
  field_domain,
 
5060
  field_domain::proto_grammar,
 
5061
  boost::mpl::and_<
 
5062
    boost::mpl::or_<is_field<field_expr<Expr1> >, is_field<field_expr<Expr2> > >,
 
5063
    boost::mpl::not_<
 
5064
      boost::mpl::or_<
 
5065
        boost::proto::is_extension<field_expr<Expr1> >,
 
5066
        boost::proto::is_extension<field_expr<Expr2> >
 
5067
      >
 
5068
    >
 
5069
  >,
 
5070
  boost::proto::tag::minus,
 
5071
  field_expr<Expr1> const &,
 
5072
  field_expr<Expr2> const &
 
5073
>::type /* const */
 
5074
operator- (field_expr<Expr1> const &left, field_expr<Expr2> const &right)
 
5075
{
 
5076
  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_expr<Expr1> const &, field_expr<Expr2> const &>()(left, right);
 
5077
}
 
5078
#endif // BOOST_VERSION
1166
5079
template<class T, class M>
 
5080
#if BOOST_VERSION < 104601
1167
5081
typename
1168
5082
boost::proto::detail::enable_binary<
1169
5083
  field_domain,
1177
5091
operator* (const int& l, const field_basic<T,M>& r)
1178
5092
{
1179
5093
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1180
 
    ::impl<const int&,   const field_basic<T,M>&>() (l, r);
1181
 
}
 
5094
    ::impl<const int&, const field_basic<T,M>&>() (l, r);
 
5095
}
 
5096
#else // BOOST_VERSION >= 104601
 
5097
typename boost::proto::detail::enable_binary< 
 
5098
  field_domain,
 
5099
  field_domain::proto_grammar,
 
5100
  boost::mpl::and_<
 
5101
    boost::mpl::or_<is_field<int >, is_field<field_basic<T,M> > >,
 
5102
    boost::mpl::not_<
 
5103
      boost::mpl::or_<
 
5104
        boost::proto::is_extension<int >,
 
5105
        boost::proto::is_extension<field_basic<T,M> >
 
5106
      >
 
5107
    >
 
5108
  >,
 
5109
  boost::proto::tag::multiplies,
 
5110
  int const &,
 
5111
  field_basic<T,M> const &
 
5112
>::type /* const */
 
5113
operator* (int const &left, field_basic<T,M> const &right)
 
5114
{
 
5115
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, int const &, field_basic<T,M> const &>()(left, right);
 
5116
}
 
5117
#endif // BOOST_VERSION
1182
5118
template<class T, class M>
 
5119
#if BOOST_VERSION < 104601
1183
5120
typename
1184
5121
boost::proto::detail::enable_binary<
1185
5122
  field_domain,
1193
5130
operator* (const T& l, const field_basic<T,M>& r)
1194
5131
{
1195
5132
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1196
 
    ::impl<const T&,   const field_basic<T,M>&>() (l, r);
1197
 
}
 
5133
    ::impl<const T&, const field_basic<T,M>&>() (l, r);
 
5134
}
 
5135
#else // BOOST_VERSION >= 104601
 
5136
typename boost::proto::detail::enable_binary< 
 
5137
  field_domain,
 
5138
  field_domain::proto_grammar,
 
5139
  boost::mpl::and_<
 
5140
    boost::mpl::or_<is_field<T >, is_field<field_basic<T,M> > >,
 
5141
    boost::mpl::not_<
 
5142
      boost::mpl::or_<
 
5143
        boost::proto::is_extension<T >,
 
5144
        boost::proto::is_extension<field_basic<T,M> >
 
5145
      >
 
5146
    >
 
5147
  >,
 
5148
  boost::proto::tag::multiplies,
 
5149
  T const &,
 
5150
  field_basic<T,M> const &
 
5151
>::type /* const */
 
5152
operator* (T const &left, field_basic<T,M> const &right)
 
5153
{
 
5154
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, T const &, field_basic<T,M> const &>()(left, right);
 
5155
}
 
5156
#endif // BOOST_VERSION
1198
5157
template<class T, class M>
 
5158
#if BOOST_VERSION < 104601
1199
5159
typename
1200
5160
boost::proto::detail::enable_binary<
1201
5161
  field_domain,
1209
5169
operator* (const int& l, const field_indirect<T,M>& r)
1210
5170
{
1211
5171
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1212
 
    ::impl<const int&,   const field_indirect<T,M>&>() (l, r);
1213
 
}
 
5172
    ::impl<const int&, const field_indirect<T,M>&>() (l, r);
 
5173
}
 
5174
#else // BOOST_VERSION >= 104601
 
5175
typename boost::proto::detail::enable_binary< 
 
5176
  field_domain,
 
5177
  field_domain::proto_grammar,
 
5178
  boost::mpl::and_<
 
5179
    boost::mpl::or_<is_field<int >, is_field<field_indirect<T,M> > >,
 
5180
    boost::mpl::not_<
 
5181
      boost::mpl::or_<
 
5182
        boost::proto::is_extension<int >,
 
5183
        boost::proto::is_extension<field_indirect<T,M> >
 
5184
      >
 
5185
    >
 
5186
  >,
 
5187
  boost::proto::tag::multiplies,
 
5188
  int const &,
 
5189
  field_indirect<T,M> const &
 
5190
>::type /* const */
 
5191
operator* (int const &left, field_indirect<T,M> const &right)
 
5192
{
 
5193
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, int const &, field_indirect<T,M> const &>()(left, right);
 
5194
}
 
5195
#endif // BOOST_VERSION
1214
5196
template<class T, class M>
 
5197
#if BOOST_VERSION < 104601
1215
5198
typename
1216
5199
boost::proto::detail::enable_binary<
1217
5200
  field_domain,
1225
5208
operator* (const T& l, const field_indirect<T,M>& r)
1226
5209
{
1227
5210
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1228
 
    ::impl<const T&,   const field_indirect<T,M>&>() (l, r);
1229
 
}
 
5211
    ::impl<const T&, const field_indirect<T,M>&>() (l, r);
 
5212
}
 
5213
#else // BOOST_VERSION >= 104601
 
5214
typename boost::proto::detail::enable_binary< 
 
5215
  field_domain,
 
5216
  field_domain::proto_grammar,
 
5217
  boost::mpl::and_<
 
5218
    boost::mpl::or_<is_field<T >, is_field<field_indirect<T,M> > >,
 
5219
    boost::mpl::not_<
 
5220
      boost::mpl::or_<
 
5221
        boost::proto::is_extension<T >,
 
5222
        boost::proto::is_extension<field_indirect<T,M> >
 
5223
      >
 
5224
    >
 
5225
  >,
 
5226
  boost::proto::tag::multiplies,
 
5227
  T const &,
 
5228
  field_indirect<T,M> const &
 
5229
>::type /* const */
 
5230
operator* (T const &left, field_indirect<T,M> const &right)
 
5231
{
 
5232
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, T const &, field_indirect<T,M> const &>()(left, right);
 
5233
}
 
5234
#endif // BOOST_VERSION
1230
5235
template<class T, class M>
 
5236
#if BOOST_VERSION < 104601
1231
5237
typename
1232
5238
boost::proto::detail::enable_binary<
1233
5239
  field_domain,
1241
5247
operator* (const int& l, const field_indirect_const<T,M>& r)
1242
5248
{
1243
5249
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1244
 
    ::impl<const int&,   const field_indirect_const<T,M>&>() (l, r);
1245
 
}
 
5250
    ::impl<const int&, const field_indirect_const<T,M>&>() (l, r);
 
5251
}
 
5252
#else // BOOST_VERSION >= 104601
 
5253
typename boost::proto::detail::enable_binary< 
 
5254
  field_domain,
 
5255
  field_domain::proto_grammar,
 
5256
  boost::mpl::and_<
 
5257
    boost::mpl::or_<is_field<int >, is_field<field_indirect_const<T,M> > >,
 
5258
    boost::mpl::not_<
 
5259
      boost::mpl::or_<
 
5260
        boost::proto::is_extension<int >,
 
5261
        boost::proto::is_extension<field_indirect_const<T,M> >
 
5262
      >
 
5263
    >
 
5264
  >,
 
5265
  boost::proto::tag::multiplies,
 
5266
  int const &,
 
5267
  field_indirect_const<T,M> const &
 
5268
>::type /* const */
 
5269
operator* (int const &left, field_indirect_const<T,M> const &right)
 
5270
{
 
5271
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, int const &, field_indirect_const<T,M> const &>()(left, right);
 
5272
}
 
5273
#endif // BOOST_VERSION
1246
5274
template<class T, class M>
 
5275
#if BOOST_VERSION < 104601
1247
5276
typename
1248
5277
boost::proto::detail::enable_binary<
1249
5278
  field_domain,
1257
5286
operator* (const T& l, const field_indirect_const<T,M>& r)
1258
5287
{
1259
5288
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1260
 
    ::impl<const T&,   const field_indirect_const<T,M>&>() (l, r);
1261
 
}
1262
 
template<class T, class M>
 
5289
    ::impl<const T&, const field_indirect_const<T,M>&>() (l, r);
 
5290
}
 
5291
#else // BOOST_VERSION >= 104601
 
5292
typename boost::proto::detail::enable_binary< 
 
5293
  field_domain,
 
5294
  field_domain::proto_grammar,
 
5295
  boost::mpl::and_<
 
5296
    boost::mpl::or_<is_field<T >, is_field<field_indirect_const<T,M> > >,
 
5297
    boost::mpl::not_<
 
5298
      boost::mpl::or_<
 
5299
        boost::proto::is_extension<T >,
 
5300
        boost::proto::is_extension<field_indirect_const<T,M> >
 
5301
      >
 
5302
    >
 
5303
  >,
 
5304
  boost::proto::tag::multiplies,
 
5305
  T const &,
 
5306
  field_indirect_const<T,M> const &
 
5307
>::type /* const */
 
5308
operator* (T const &left, field_indirect_const<T,M> const &right)
 
5309
{
 
5310
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, T const &, field_indirect_const<T,M> const &>()(left, right);
 
5311
}
 
5312
#endif // BOOST_VERSION
 
5313
template<class T, class M>
 
5314
#if BOOST_VERSION < 104601
 
5315
typename
 
5316
boost::proto::detail::enable_binary<
 
5317
  field_domain,
 
5318
  is_field<int >,
 
5319
  int,
 
5320
  is_field<field_component<T,M> >,
 
5321
  field_component<T,M>,
 
5322
  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
5323
    ::impl<const int&,   const field_component<T,M>&>::result_type const
 
5324
>::type
 
5325
operator* (const int& l, const field_component<T,M>& r)
 
5326
{
 
5327
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
5328
    ::impl<const int&, const field_component<T,M>&>() (l, r);
 
5329
}
 
5330
#else // BOOST_VERSION >= 104601
 
5331
typename boost::proto::detail::enable_binary< 
 
5332
  field_domain,
 
5333
  field_domain::proto_grammar,
 
5334
  boost::mpl::and_<
 
5335
    boost::mpl::or_<is_field<int >, is_field<field_component<T,M> > >,
 
5336
    boost::mpl::not_<
 
5337
      boost::mpl::or_<
 
5338
        boost::proto::is_extension<int >,
 
5339
        boost::proto::is_extension<field_component<T,M> >
 
5340
      >
 
5341
    >
 
5342
  >,
 
5343
  boost::proto::tag::multiplies,
 
5344
  int const &,
 
5345
  field_component<T,M> const &
 
5346
>::type /* const */
 
5347
operator* (int const &left, field_component<T,M> const &right)
 
5348
{
 
5349
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, int const &, field_component<T,M> const &>()(left, right);
 
5350
}
 
5351
#endif // BOOST_VERSION
 
5352
template<class T, class M>
 
5353
#if BOOST_VERSION < 104601
 
5354
typename
 
5355
boost::proto::detail::enable_binary<
 
5356
  field_domain,
 
5357
  is_field<T >,
 
5358
  T,
 
5359
  is_field<field_component<T,M> >,
 
5360
  field_component<T,M>,
 
5361
  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
5362
    ::impl<const T&,   const field_component<T,M>&>::result_type const
 
5363
>::type
 
5364
operator* (const T& l, const field_component<T,M>& r)
 
5365
{
 
5366
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
5367
    ::impl<const T&, const field_component<T,M>&>() (l, r);
 
5368
}
 
5369
#else // BOOST_VERSION >= 104601
 
5370
typename boost::proto::detail::enable_binary< 
 
5371
  field_domain,
 
5372
  field_domain::proto_grammar,
 
5373
  boost::mpl::and_<
 
5374
    boost::mpl::or_<is_field<T >, is_field<field_component<T,M> > >,
 
5375
    boost::mpl::not_<
 
5376
      boost::mpl::or_<
 
5377
        boost::proto::is_extension<T >,
 
5378
        boost::proto::is_extension<field_component<T,M> >
 
5379
      >
 
5380
    >
 
5381
  >,
 
5382
  boost::proto::tag::multiplies,
 
5383
  T const &,
 
5384
  field_component<T,M> const &
 
5385
>::type /* const */
 
5386
operator* (T const &left, field_component<T,M> const &right)
 
5387
{
 
5388
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, T const &, field_component<T,M> const &>()(left, right);
 
5389
}
 
5390
#endif // BOOST_VERSION
 
5391
template<class T, class M>
 
5392
#if BOOST_VERSION < 104601
 
5393
typename
 
5394
boost::proto::detail::enable_binary<
 
5395
  field_domain,
 
5396
  is_field<int >,
 
5397
  int,
 
5398
  is_field<field_component_const<T,M> >,
 
5399
  field_component_const<T,M>,
 
5400
  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
5401
    ::impl<const int&,   const field_component_const<T,M>&>::result_type const
 
5402
>::type
 
5403
operator* (const int& l, const field_component_const<T,M>& r)
 
5404
{
 
5405
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
5406
    ::impl<const int&, const field_component_const<T,M>&>() (l, r);
 
5407
}
 
5408
#else // BOOST_VERSION >= 104601
 
5409
typename boost::proto::detail::enable_binary< 
 
5410
  field_domain,
 
5411
  field_domain::proto_grammar,
 
5412
  boost::mpl::and_<
 
5413
    boost::mpl::or_<is_field<int >, is_field<field_component_const<T,M> > >,
 
5414
    boost::mpl::not_<
 
5415
      boost::mpl::or_<
 
5416
        boost::proto::is_extension<int >,
 
5417
        boost::proto::is_extension<field_component_const<T,M> >
 
5418
      >
 
5419
    >
 
5420
  >,
 
5421
  boost::proto::tag::multiplies,
 
5422
  int const &,
 
5423
  field_component_const<T,M> const &
 
5424
>::type /* const */
 
5425
operator* (int const &left, field_component_const<T,M> const &right)
 
5426
{
 
5427
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, int const &, field_component_const<T,M> const &>()(left, right);
 
5428
}
 
5429
#endif // BOOST_VERSION
 
5430
template<class T, class M>
 
5431
#if BOOST_VERSION < 104601
 
5432
typename
 
5433
boost::proto::detail::enable_binary<
 
5434
  field_domain,
 
5435
  is_field<T >,
 
5436
  T,
 
5437
  is_field<field_component_const<T,M> >,
 
5438
  field_component_const<T,M>,
 
5439
  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
5440
    ::impl<const T&,   const field_component_const<T,M>&>::result_type const
 
5441
>::type
 
5442
operator* (const T& l, const field_component_const<T,M>& r)
 
5443
{
 
5444
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
5445
    ::impl<const T&, const field_component_const<T,M>&>() (l, r);
 
5446
}
 
5447
#else // BOOST_VERSION >= 104601
 
5448
typename boost::proto::detail::enable_binary< 
 
5449
  field_domain,
 
5450
  field_domain::proto_grammar,
 
5451
  boost::mpl::and_<
 
5452
    boost::mpl::or_<is_field<T >, is_field<field_component_const<T,M> > >,
 
5453
    boost::mpl::not_<
 
5454
      boost::mpl::or_<
 
5455
        boost::proto::is_extension<T >,
 
5456
        boost::proto::is_extension<field_component_const<T,M> >
 
5457
      >
 
5458
    >
 
5459
  >,
 
5460
  boost::proto::tag::multiplies,
 
5461
  T const &,
 
5462
  field_component_const<T,M> const &
 
5463
>::type /* const */
 
5464
operator* (T const &left, field_component_const<T,M> const &right)
 
5465
{
 
5466
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, T const &, field_component_const<T,M> const &>()(left, right);
 
5467
}
 
5468
#endif // BOOST_VERSION
 
5469
template<class T, class M>
 
5470
#if BOOST_VERSION < 104601
1263
5471
typename
1264
5472
boost::proto::detail::enable_binary<
1265
5473
  field_domain,
1273
5481
operator* (const field_basic<T,M>& l, const int& r)
1274
5482
{
1275
5483
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1276
 
    ::impl<const field_basic<T,M>&,   const int&>() (l, r);
1277
 
}
 
5484
    ::impl<const field_basic<T,M>&, const int&>() (l, r);
 
5485
}
 
5486
#else // BOOST_VERSION >= 104601
 
5487
typename boost::proto::detail::enable_binary< 
 
5488
  field_domain,
 
5489
  field_domain::proto_grammar,
 
5490
  boost::mpl::and_<
 
5491
    boost::mpl::or_<is_field<field_basic<T,M> >, is_field<int > >,
 
5492
    boost::mpl::not_<
 
5493
      boost::mpl::or_<
 
5494
        boost::proto::is_extension<field_basic<T,M> >,
 
5495
        boost::proto::is_extension<int >
 
5496
      >
 
5497
    >
 
5498
  >,
 
5499
  boost::proto::tag::multiplies,
 
5500
  field_basic<T,M> const &,
 
5501
  int const &
 
5502
>::type /* const */
 
5503
operator* (field_basic<T,M> const &left, int const &right)
 
5504
{
 
5505
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_basic<T,M> const &, int const &>()(left, right);
 
5506
}
 
5507
#endif // BOOST_VERSION
1278
5508
template<class T, class M>
 
5509
#if BOOST_VERSION < 104601
1279
5510
typename
1280
5511
boost::proto::detail::enable_binary<
1281
5512
  field_domain,
1289
5520
operator* (const field_basic<T,M>& l, const T& r)
1290
5521
{
1291
5522
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1292
 
    ::impl<const field_basic<T,M>&,   const T&>() (l, r);
1293
 
}
 
5523
    ::impl<const field_basic<T,M>&, const T&>() (l, r);
 
5524
}
 
5525
#else // BOOST_VERSION >= 104601
 
5526
typename boost::proto::detail::enable_binary< 
 
5527
  field_domain,
 
5528
  field_domain::proto_grammar,
 
5529
  boost::mpl::and_<
 
5530
    boost::mpl::or_<is_field<field_basic<T,M> >, is_field<T > >,
 
5531
    boost::mpl::not_<
 
5532
      boost::mpl::or_<
 
5533
        boost::proto::is_extension<field_basic<T,M> >,
 
5534
        boost::proto::is_extension<T >
 
5535
      >
 
5536
    >
 
5537
  >,
 
5538
  boost::proto::tag::multiplies,
 
5539
  field_basic<T,M> const &,
 
5540
  T const &
 
5541
>::type /* const */
 
5542
operator* (field_basic<T,M> const &left, T const &right)
 
5543
{
 
5544
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_basic<T,M> const &, T const &>()(left, right);
 
5545
}
 
5546
#endif // BOOST_VERSION
1294
5547
template<class T, class M>
 
5548
#if BOOST_VERSION < 104601
1295
5549
typename
1296
5550
boost::proto::detail::enable_binary<
1297
5551
  field_domain,
1305
5559
operator* (const field_indirect<T,M>& l, const int& r)
1306
5560
{
1307
5561
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1308
 
    ::impl<const field_indirect<T,M>&,   const int&>() (l, r);
1309
 
}
 
5562
    ::impl<const field_indirect<T,M>&, const int&>() (l, r);
 
5563
}
 
5564
#else // BOOST_VERSION >= 104601
 
5565
typename boost::proto::detail::enable_binary< 
 
5566
  field_domain,
 
5567
  field_domain::proto_grammar,
 
5568
  boost::mpl::and_<
 
5569
    boost::mpl::or_<is_field<field_indirect<T,M> >, is_field<int > >,
 
5570
    boost::mpl::not_<
 
5571
      boost::mpl::or_<
 
5572
        boost::proto::is_extension<field_indirect<T,M> >,
 
5573
        boost::proto::is_extension<int >
 
5574
      >
 
5575
    >
 
5576
  >,
 
5577
  boost::proto::tag::multiplies,
 
5578
  field_indirect<T,M> const &,
 
5579
  int const &
 
5580
>::type /* const */
 
5581
operator* (field_indirect<T,M> const &left, int const &right)
 
5582
{
 
5583
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_indirect<T,M> const &, int const &>()(left, right);
 
5584
}
 
5585
#endif // BOOST_VERSION
1310
5586
template<class T, class M>
 
5587
#if BOOST_VERSION < 104601
1311
5588
typename
1312
5589
boost::proto::detail::enable_binary<
1313
5590
  field_domain,
1321
5598
operator* (const field_indirect<T,M>& l, const T& r)
1322
5599
{
1323
5600
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1324
 
    ::impl<const field_indirect<T,M>&,   const T&>() (l, r);
1325
 
}
 
5601
    ::impl<const field_indirect<T,M>&, const T&>() (l, r);
 
5602
}
 
5603
#else // BOOST_VERSION >= 104601
 
5604
typename boost::proto::detail::enable_binary< 
 
5605
  field_domain,
 
5606
  field_domain::proto_grammar,
 
5607
  boost::mpl::and_<
 
5608
    boost::mpl::or_<is_field<field_indirect<T,M> >, is_field<T > >,
 
5609
    boost::mpl::not_<
 
5610
      boost::mpl::or_<
 
5611
        boost::proto::is_extension<field_indirect<T,M> >,
 
5612
        boost::proto::is_extension<T >
 
5613
      >
 
5614
    >
 
5615
  >,
 
5616
  boost::proto::tag::multiplies,
 
5617
  field_indirect<T,M> const &,
 
5618
  T const &
 
5619
>::type /* const */
 
5620
operator* (field_indirect<T,M> const &left, T const &right)
 
5621
{
 
5622
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_indirect<T,M> const &, T const &>()(left, right);
 
5623
}
 
5624
#endif // BOOST_VERSION
1326
5625
template<class T, class M>
 
5626
#if BOOST_VERSION < 104601
1327
5627
typename
1328
5628
boost::proto::detail::enable_binary<
1329
5629
  field_domain,
1337
5637
operator* (const field_indirect_const<T,M>& l, const int& r)
1338
5638
{
1339
5639
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1340
 
    ::impl<const field_indirect_const<T,M>&,   const int&>() (l, r);
1341
 
}
 
5640
    ::impl<const field_indirect_const<T,M>&, const int&>() (l, r);
 
5641
}
 
5642
#else // BOOST_VERSION >= 104601
 
5643
typename boost::proto::detail::enable_binary< 
 
5644
  field_domain,
 
5645
  field_domain::proto_grammar,
 
5646
  boost::mpl::and_<
 
5647
    boost::mpl::or_<is_field<field_indirect_const<T,M> >, is_field<int > >,
 
5648
    boost::mpl::not_<
 
5649
      boost::mpl::or_<
 
5650
        boost::proto::is_extension<field_indirect_const<T,M> >,
 
5651
        boost::proto::is_extension<int >
 
5652
      >
 
5653
    >
 
5654
  >,
 
5655
  boost::proto::tag::multiplies,
 
5656
  field_indirect_const<T,M> const &,
 
5657
  int const &
 
5658
>::type /* const */
 
5659
operator* (field_indirect_const<T,M> const &left, int const &right)
 
5660
{
 
5661
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_indirect_const<T,M> const &, int const &>()(left, right);
 
5662
}
 
5663
#endif // BOOST_VERSION
1342
5664
template<class T, class M>
 
5665
#if BOOST_VERSION < 104601
1343
5666
typename
1344
5667
boost::proto::detail::enable_binary<
1345
5668
  field_domain,
1353
5676
operator* (const field_indirect_const<T,M>& l, const T& r)
1354
5677
{
1355
5678
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1356
 
    ::impl<const field_indirect_const<T,M>&,   const T&>() (l, r);
1357
 
}
 
5679
    ::impl<const field_indirect_const<T,M>&, const T&>() (l, r);
 
5680
}
 
5681
#else // BOOST_VERSION >= 104601
 
5682
typename boost::proto::detail::enable_binary< 
 
5683
  field_domain,
 
5684
  field_domain::proto_grammar,
 
5685
  boost::mpl::and_<
 
5686
    boost::mpl::or_<is_field<field_indirect_const<T,M> >, is_field<T > >,
 
5687
    boost::mpl::not_<
 
5688
      boost::mpl::or_<
 
5689
        boost::proto::is_extension<field_indirect_const<T,M> >,
 
5690
        boost::proto::is_extension<T >
 
5691
      >
 
5692
    >
 
5693
  >,
 
5694
  boost::proto::tag::multiplies,
 
5695
  field_indirect_const<T,M> const &,
 
5696
  T const &
 
5697
>::type /* const */
 
5698
operator* (field_indirect_const<T,M> const &left, T const &right)
 
5699
{
 
5700
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_indirect_const<T,M> const &, T const &>()(left, right);
 
5701
}
 
5702
#endif // BOOST_VERSION
 
5703
template<class T, class M>
 
5704
#if BOOST_VERSION < 104601
 
5705
typename
 
5706
boost::proto::detail::enable_binary<
 
5707
  field_domain,
 
5708
  is_field<field_component<T,M> >,
 
5709
  field_component<T,M>,
 
5710
  is_field<int >,
 
5711
  int,
 
5712
  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
5713
    ::impl<const field_component<T,M>&,   const int&>::result_type const
 
5714
>::type
 
5715
operator* (const field_component<T,M>& l, const int& r)
 
5716
{
 
5717
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
5718
    ::impl<const field_component<T,M>&, const int&>() (l, r);
 
5719
}
 
5720
#else // BOOST_VERSION >= 104601
 
5721
typename boost::proto::detail::enable_binary< 
 
5722
  field_domain,
 
5723
  field_domain::proto_grammar,
 
5724
  boost::mpl::and_<
 
5725
    boost::mpl::or_<is_field<field_component<T,M> >, is_field<int > >,
 
5726
    boost::mpl::not_<
 
5727
      boost::mpl::or_<
 
5728
        boost::proto::is_extension<field_component<T,M> >,
 
5729
        boost::proto::is_extension<int >
 
5730
      >
 
5731
    >
 
5732
  >,
 
5733
  boost::proto::tag::multiplies,
 
5734
  field_component<T,M> const &,
 
5735
  int const &
 
5736
>::type /* const */
 
5737
operator* (field_component<T,M> const &left, int const &right)
 
5738
{
 
5739
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_component<T,M> const &, int const &>()(left, right);
 
5740
}
 
5741
#endif // BOOST_VERSION
 
5742
template<class T, class M>
 
5743
#if BOOST_VERSION < 104601
 
5744
typename
 
5745
boost::proto::detail::enable_binary<
 
5746
  field_domain,
 
5747
  is_field<field_component<T,M> >,
 
5748
  field_component<T,M>,
 
5749
  is_field<T >,
 
5750
  T,
 
5751
  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
5752
    ::impl<const field_component<T,M>&,   const T&>::result_type const
 
5753
>::type
 
5754
operator* (const field_component<T,M>& l, const T& r)
 
5755
{
 
5756
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
5757
    ::impl<const field_component<T,M>&, const T&>() (l, r);
 
5758
}
 
5759
#else // BOOST_VERSION >= 104601
 
5760
typename boost::proto::detail::enable_binary< 
 
5761
  field_domain,
 
5762
  field_domain::proto_grammar,
 
5763
  boost::mpl::and_<
 
5764
    boost::mpl::or_<is_field<field_component<T,M> >, is_field<T > >,
 
5765
    boost::mpl::not_<
 
5766
      boost::mpl::or_<
 
5767
        boost::proto::is_extension<field_component<T,M> >,
 
5768
        boost::proto::is_extension<T >
 
5769
      >
 
5770
    >
 
5771
  >,
 
5772
  boost::proto::tag::multiplies,
 
5773
  field_component<T,M> const &,
 
5774
  T const &
 
5775
>::type /* const */
 
5776
operator* (field_component<T,M> const &left, T const &right)
 
5777
{
 
5778
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_component<T,M> const &, T const &>()(left, right);
 
5779
}
 
5780
#endif // BOOST_VERSION
 
5781
template<class T, class M>
 
5782
#if BOOST_VERSION < 104601
 
5783
typename
 
5784
boost::proto::detail::enable_binary<
 
5785
  field_domain,
 
5786
  is_field<field_component_const<T,M> >,
 
5787
  field_component_const<T,M>,
 
5788
  is_field<int >,
 
5789
  int,
 
5790
  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
5791
    ::impl<const field_component_const<T,M>&,   const int&>::result_type const
 
5792
>::type
 
5793
operator* (const field_component_const<T,M>& l, const int& r)
 
5794
{
 
5795
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
5796
    ::impl<const field_component_const<T,M>&, const int&>() (l, r);
 
5797
}
 
5798
#else // BOOST_VERSION >= 104601
 
5799
typename boost::proto::detail::enable_binary< 
 
5800
  field_domain,
 
5801
  field_domain::proto_grammar,
 
5802
  boost::mpl::and_<
 
5803
    boost::mpl::or_<is_field<field_component_const<T,M> >, is_field<int > >,
 
5804
    boost::mpl::not_<
 
5805
      boost::mpl::or_<
 
5806
        boost::proto::is_extension<field_component_const<T,M> >,
 
5807
        boost::proto::is_extension<int >
 
5808
      >
 
5809
    >
 
5810
  >,
 
5811
  boost::proto::tag::multiplies,
 
5812
  field_component_const<T,M> const &,
 
5813
  int const &
 
5814
>::type /* const */
 
5815
operator* (field_component_const<T,M> const &left, int const &right)
 
5816
{
 
5817
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_component_const<T,M> const &, int const &>()(left, right);
 
5818
}
 
5819
#endif // BOOST_VERSION
 
5820
template<class T, class M>
 
5821
#if BOOST_VERSION < 104601
 
5822
typename
 
5823
boost::proto::detail::enable_binary<
 
5824
  field_domain,
 
5825
  is_field<field_component_const<T,M> >,
 
5826
  field_component_const<T,M>,
 
5827
  is_field<T >,
 
5828
  T,
 
5829
  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
5830
    ::impl<const field_component_const<T,M>&,   const T&>::result_type const
 
5831
>::type
 
5832
operator* (const field_component_const<T,M>& l, const T& r)
 
5833
{
 
5834
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
5835
    ::impl<const field_component_const<T,M>&, const T&>() (l, r);
 
5836
}
 
5837
#else // BOOST_VERSION >= 104601
 
5838
typename boost::proto::detail::enable_binary< 
 
5839
  field_domain,
 
5840
  field_domain::proto_grammar,
 
5841
  boost::mpl::and_<
 
5842
    boost::mpl::or_<is_field<field_component_const<T,M> >, is_field<T > >,
 
5843
    boost::mpl::not_<
 
5844
      boost::mpl::or_<
 
5845
        boost::proto::is_extension<field_component_const<T,M> >,
 
5846
        boost::proto::is_extension<T >
 
5847
      >
 
5848
    >
 
5849
  >,
 
5850
  boost::proto::tag::multiplies,
 
5851
  field_component_const<T,M> const &,
 
5852
  T const &
 
5853
>::type /* const */
 
5854
operator* (field_component_const<T,M> const &left, T const &right)
 
5855
{
 
5856
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_component_const<T,M> const &, T const &>()(left, right);
 
5857
}
 
5858
#endif // BOOST_VERSION
1358
5859
template<class T1, class T2, class M>
 
5860
#if BOOST_VERSION < 104601
1359
5861
typename
1360
5862
boost::proto::detail::enable_binary<
1361
5863
  field_domain,
1369
5871
operator* (const field_basic<T1,M>& l, const field_basic<T2,M>& r)
1370
5872
{
1371
5873
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1372
 
    ::impl<const field_basic<T1,M>&,   const field_basic<T2,M>&>() (l, r);
1373
 
}
 
5874
    ::impl<const field_basic<T1,M>&, const field_basic<T2,M>&>() (l, r);
 
5875
}
 
5876
#else // BOOST_VERSION >= 104601
 
5877
typename boost::proto::detail::enable_binary< 
 
5878
  field_domain,
 
5879
  field_domain::proto_grammar,
 
5880
  boost::mpl::and_<
 
5881
    boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_basic<T2,M> > >,
 
5882
    boost::mpl::not_<
 
5883
      boost::mpl::or_<
 
5884
        boost::proto::is_extension<field_basic<T1,M> >,
 
5885
        boost::proto::is_extension<field_basic<T2,M> >
 
5886
      >
 
5887
    >
 
5888
  >,
 
5889
  boost::proto::tag::multiplies,
 
5890
  field_basic<T1,M> const &,
 
5891
  field_basic<T2,M> const &
 
5892
>::type /* const */
 
5893
operator* (field_basic<T1,M> const &left, field_basic<T2,M> const &right)
 
5894
{
 
5895
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_basic<T1,M> const &, field_basic<T2,M> const &>()(left, right);
 
5896
}
 
5897
#endif // BOOST_VERSION
1374
5898
template<class T1, class T2, class M>
 
5899
#if BOOST_VERSION < 104601
1375
5900
typename
1376
5901
boost::proto::detail::enable_binary<
1377
5902
  field_domain,
1385
5910
operator* (const field_basic<T1,M>& l, const field_indirect<T2,M>& r)
1386
5911
{
1387
5912
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1388
 
    ::impl<const field_basic<T1,M>&,   const field_indirect<T2,M>&>() (l, r);
1389
 
}
 
5913
    ::impl<const field_basic<T1,M>&, const field_indirect<T2,M>&>() (l, r);
 
5914
}
 
5915
#else // BOOST_VERSION >= 104601
 
5916
typename boost::proto::detail::enable_binary< 
 
5917
  field_domain,
 
5918
  field_domain::proto_grammar,
 
5919
  boost::mpl::and_<
 
5920
    boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_indirect<T2,M> > >,
 
5921
    boost::mpl::not_<
 
5922
      boost::mpl::or_<
 
5923
        boost::proto::is_extension<field_basic<T1,M> >,
 
5924
        boost::proto::is_extension<field_indirect<T2,M> >
 
5925
      >
 
5926
    >
 
5927
  >,
 
5928
  boost::proto::tag::multiplies,
 
5929
  field_basic<T1,M> const &,
 
5930
  field_indirect<T2,M> const &
 
5931
>::type /* const */
 
5932
operator* (field_basic<T1,M> const &left, field_indirect<T2,M> const &right)
 
5933
{
 
5934
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_basic<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
 
5935
}
 
5936
#endif // BOOST_VERSION
1390
5937
template<class T1, class T2, class M>
 
5938
#if BOOST_VERSION < 104601
1391
5939
typename
1392
5940
boost::proto::detail::enable_binary<
1393
5941
  field_domain,
1401
5949
operator* (const field_basic<T1,M>& l, const field_indirect_const<T2,M>& r)
1402
5950
{
1403
5951
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1404
 
    ::impl<const field_basic<T1,M>&,   const field_indirect_const<T2,M>&>() (l, r);
1405
 
}
1406
 
template<class T1, class T2, class M>
 
5952
    ::impl<const field_basic<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
 
5953
}
 
5954
#else // BOOST_VERSION >= 104601
 
5955
typename boost::proto::detail::enable_binary< 
 
5956
  field_domain,
 
5957
  field_domain::proto_grammar,
 
5958
  boost::mpl::and_<
 
5959
    boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_indirect_const<T2,M> > >,
 
5960
    boost::mpl::not_<
 
5961
      boost::mpl::or_<
 
5962
        boost::proto::is_extension<field_basic<T1,M> >,
 
5963
        boost::proto::is_extension<field_indirect_const<T2,M> >
 
5964
      >
 
5965
    >
 
5966
  >,
 
5967
  boost::proto::tag::multiplies,
 
5968
  field_basic<T1,M> const &,
 
5969
  field_indirect_const<T2,M> const &
 
5970
>::type /* const */
 
5971
operator* (field_basic<T1,M> const &left, field_indirect_const<T2,M> const &right)
 
5972
{
 
5973
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_basic<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
 
5974
}
 
5975
#endif // BOOST_VERSION
 
5976
template<class T1, class T2, class M>
 
5977
#if BOOST_VERSION < 104601
 
5978
typename
 
5979
boost::proto::detail::enable_binary<
 
5980
  field_domain,
 
5981
  is_field<field_basic<T1,M> >,
 
5982
  field_basic<T1,M>,
 
5983
  is_field<field_component<T2,M> >,
 
5984
  field_component<T2,M>,
 
5985
  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
5986
    ::impl<const field_basic<T1,M>&,   const field_component<T2,M>&>::result_type const
 
5987
>::type
 
5988
operator* (const field_basic<T1,M>& l, const field_component<T2,M>& r)
 
5989
{
 
5990
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
5991
    ::impl<const field_basic<T1,M>&, const field_component<T2,M>&>() (l, r);
 
5992
}
 
5993
#else // BOOST_VERSION >= 104601
 
5994
typename boost::proto::detail::enable_binary< 
 
5995
  field_domain,
 
5996
  field_domain::proto_grammar,
 
5997
  boost::mpl::and_<
 
5998
    boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_component<T2,M> > >,
 
5999
    boost::mpl::not_<
 
6000
      boost::mpl::or_<
 
6001
        boost::proto::is_extension<field_basic<T1,M> >,
 
6002
        boost::proto::is_extension<field_component<T2,M> >
 
6003
      >
 
6004
    >
 
6005
  >,
 
6006
  boost::proto::tag::multiplies,
 
6007
  field_basic<T1,M> const &,
 
6008
  field_component<T2,M> const &
 
6009
>::type /* const */
 
6010
operator* (field_basic<T1,M> const &left, field_component<T2,M> const &right)
 
6011
{
 
6012
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_basic<T1,M> const &, field_component<T2,M> const &>()(left, right);
 
6013
}
 
6014
#endif // BOOST_VERSION
 
6015
template<class T1, class T2, class M>
 
6016
#if BOOST_VERSION < 104601
 
6017
typename
 
6018
boost::proto::detail::enable_binary<
 
6019
  field_domain,
 
6020
  is_field<field_basic<T1,M> >,
 
6021
  field_basic<T1,M>,
 
6022
  is_field<field_component_const<T2,M> >,
 
6023
  field_component_const<T2,M>,
 
6024
  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6025
    ::impl<const field_basic<T1,M>&,   const field_component_const<T2,M>&>::result_type const
 
6026
>::type
 
6027
operator* (const field_basic<T1,M>& l, const field_component_const<T2,M>& r)
 
6028
{
 
6029
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6030
    ::impl<const field_basic<T1,M>&, const field_component_const<T2,M>&>() (l, r);
 
6031
}
 
6032
#else // BOOST_VERSION >= 104601
 
6033
typename boost::proto::detail::enable_binary< 
 
6034
  field_domain,
 
6035
  field_domain::proto_grammar,
 
6036
  boost::mpl::and_<
 
6037
    boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_component_const<T2,M> > >,
 
6038
    boost::mpl::not_<
 
6039
      boost::mpl::or_<
 
6040
        boost::proto::is_extension<field_basic<T1,M> >,
 
6041
        boost::proto::is_extension<field_component_const<T2,M> >
 
6042
      >
 
6043
    >
 
6044
  >,
 
6045
  boost::proto::tag::multiplies,
 
6046
  field_basic<T1,M> const &,
 
6047
  field_component_const<T2,M> const &
 
6048
>::type /* const */
 
6049
operator* (field_basic<T1,M> const &left, field_component_const<T2,M> const &right)
 
6050
{
 
6051
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_basic<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
 
6052
}
 
6053
#endif // BOOST_VERSION
 
6054
template<class T1, class T2, class M>
 
6055
#if BOOST_VERSION < 104601
1407
6056
typename
1408
6057
boost::proto::detail::enable_binary<
1409
6058
  field_domain,
1417
6066
operator* (const field_indirect<T1,M>& l, const field_basic<T2,M>& r)
1418
6067
{
1419
6068
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1420
 
    ::impl<const field_indirect<T1,M>&,   const field_basic<T2,M>&>() (l, r);
1421
 
}
 
6069
    ::impl<const field_indirect<T1,M>&, const field_basic<T2,M>&>() (l, r);
 
6070
}
 
6071
#else // BOOST_VERSION >= 104601
 
6072
typename boost::proto::detail::enable_binary< 
 
6073
  field_domain,
 
6074
  field_domain::proto_grammar,
 
6075
  boost::mpl::and_<
 
6076
    boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_basic<T2,M> > >,
 
6077
    boost::mpl::not_<
 
6078
      boost::mpl::or_<
 
6079
        boost::proto::is_extension<field_indirect<T1,M> >,
 
6080
        boost::proto::is_extension<field_basic<T2,M> >
 
6081
      >
 
6082
    >
 
6083
  >,
 
6084
  boost::proto::tag::multiplies,
 
6085
  field_indirect<T1,M> const &,
 
6086
  field_basic<T2,M> const &
 
6087
>::type /* const */
 
6088
operator* (field_indirect<T1,M> const &left, field_basic<T2,M> const &right)
 
6089
{
 
6090
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_indirect<T1,M> const &, field_basic<T2,M> const &>()(left, right);
 
6091
}
 
6092
#endif // BOOST_VERSION
1422
6093
template<class T1, class T2, class M>
 
6094
#if BOOST_VERSION < 104601
1423
6095
typename
1424
6096
boost::proto::detail::enable_binary<
1425
6097
  field_domain,
1433
6105
operator* (const field_indirect<T1,M>& l, const field_indirect<T2,M>& r)
1434
6106
{
1435
6107
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1436
 
    ::impl<const field_indirect<T1,M>&,   const field_indirect<T2,M>&>() (l, r);
1437
 
}
 
6108
    ::impl<const field_indirect<T1,M>&, const field_indirect<T2,M>&>() (l, r);
 
6109
}
 
6110
#else // BOOST_VERSION >= 104601
 
6111
typename boost::proto::detail::enable_binary< 
 
6112
  field_domain,
 
6113
  field_domain::proto_grammar,
 
6114
  boost::mpl::and_<
 
6115
    boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_indirect<T2,M> > >,
 
6116
    boost::mpl::not_<
 
6117
      boost::mpl::or_<
 
6118
        boost::proto::is_extension<field_indirect<T1,M> >,
 
6119
        boost::proto::is_extension<field_indirect<T2,M> >
 
6120
      >
 
6121
    >
 
6122
  >,
 
6123
  boost::proto::tag::multiplies,
 
6124
  field_indirect<T1,M> const &,
 
6125
  field_indirect<T2,M> const &
 
6126
>::type /* const */
 
6127
operator* (field_indirect<T1,M> const &left, field_indirect<T2,M> const &right)
 
6128
{
 
6129
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_indirect<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
 
6130
}
 
6131
#endif // BOOST_VERSION
1438
6132
template<class T1, class T2, class M>
 
6133
#if BOOST_VERSION < 104601
1439
6134
typename
1440
6135
boost::proto::detail::enable_binary<
1441
6136
  field_domain,
1449
6144
operator* (const field_indirect<T1,M>& l, const field_indirect_const<T2,M>& r)
1450
6145
{
1451
6146
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1452
 
    ::impl<const field_indirect<T1,M>&,   const field_indirect_const<T2,M>&>() (l, r);
1453
 
}
1454
 
template<class T1, class T2, class M>
 
6147
    ::impl<const field_indirect<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
 
6148
}
 
6149
#else // BOOST_VERSION >= 104601
 
6150
typename boost::proto::detail::enable_binary< 
 
6151
  field_domain,
 
6152
  field_domain::proto_grammar,
 
6153
  boost::mpl::and_<
 
6154
    boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_indirect_const<T2,M> > >,
 
6155
    boost::mpl::not_<
 
6156
      boost::mpl::or_<
 
6157
        boost::proto::is_extension<field_indirect<T1,M> >,
 
6158
        boost::proto::is_extension<field_indirect_const<T2,M> >
 
6159
      >
 
6160
    >
 
6161
  >,
 
6162
  boost::proto::tag::multiplies,
 
6163
  field_indirect<T1,M> const &,
 
6164
  field_indirect_const<T2,M> const &
 
6165
>::type /* const */
 
6166
operator* (field_indirect<T1,M> const &left, field_indirect_const<T2,M> const &right)
 
6167
{
 
6168
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_indirect<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
 
6169
}
 
6170
#endif // BOOST_VERSION
 
6171
template<class T1, class T2, class M>
 
6172
#if BOOST_VERSION < 104601
 
6173
typename
 
6174
boost::proto::detail::enable_binary<
 
6175
  field_domain,
 
6176
  is_field<field_indirect<T1,M> >,
 
6177
  field_indirect<T1,M>,
 
6178
  is_field<field_component<T2,M> >,
 
6179
  field_component<T2,M>,
 
6180
  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6181
    ::impl<const field_indirect<T1,M>&,   const field_component<T2,M>&>::result_type const
 
6182
>::type
 
6183
operator* (const field_indirect<T1,M>& l, const field_component<T2,M>& r)
 
6184
{
 
6185
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6186
    ::impl<const field_indirect<T1,M>&, const field_component<T2,M>&>() (l, r);
 
6187
}
 
6188
#else // BOOST_VERSION >= 104601
 
6189
typename boost::proto::detail::enable_binary< 
 
6190
  field_domain,
 
6191
  field_domain::proto_grammar,
 
6192
  boost::mpl::and_<
 
6193
    boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_component<T2,M> > >,
 
6194
    boost::mpl::not_<
 
6195
      boost::mpl::or_<
 
6196
        boost::proto::is_extension<field_indirect<T1,M> >,
 
6197
        boost::proto::is_extension<field_component<T2,M> >
 
6198
      >
 
6199
    >
 
6200
  >,
 
6201
  boost::proto::tag::multiplies,
 
6202
  field_indirect<T1,M> const &,
 
6203
  field_component<T2,M> const &
 
6204
>::type /* const */
 
6205
operator* (field_indirect<T1,M> const &left, field_component<T2,M> const &right)
 
6206
{
 
6207
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_indirect<T1,M> const &, field_component<T2,M> const &>()(left, right);
 
6208
}
 
6209
#endif // BOOST_VERSION
 
6210
template<class T1, class T2, class M>
 
6211
#if BOOST_VERSION < 104601
 
6212
typename
 
6213
boost::proto::detail::enable_binary<
 
6214
  field_domain,
 
6215
  is_field<field_indirect<T1,M> >,
 
6216
  field_indirect<T1,M>,
 
6217
  is_field<field_component_const<T2,M> >,
 
6218
  field_component_const<T2,M>,
 
6219
  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6220
    ::impl<const field_indirect<T1,M>&,   const field_component_const<T2,M>&>::result_type const
 
6221
>::type
 
6222
operator* (const field_indirect<T1,M>& l, const field_component_const<T2,M>& r)
 
6223
{
 
6224
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6225
    ::impl<const field_indirect<T1,M>&, const field_component_const<T2,M>&>() (l, r);
 
6226
}
 
6227
#else // BOOST_VERSION >= 104601
 
6228
typename boost::proto::detail::enable_binary< 
 
6229
  field_domain,
 
6230
  field_domain::proto_grammar,
 
6231
  boost::mpl::and_<
 
6232
    boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_component_const<T2,M> > >,
 
6233
    boost::mpl::not_<
 
6234
      boost::mpl::or_<
 
6235
        boost::proto::is_extension<field_indirect<T1,M> >,
 
6236
        boost::proto::is_extension<field_component_const<T2,M> >
 
6237
      >
 
6238
    >
 
6239
  >,
 
6240
  boost::proto::tag::multiplies,
 
6241
  field_indirect<T1,M> const &,
 
6242
  field_component_const<T2,M> const &
 
6243
>::type /* const */
 
6244
operator* (field_indirect<T1,M> const &left, field_component_const<T2,M> const &right)
 
6245
{
 
6246
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_indirect<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
 
6247
}
 
6248
#endif // BOOST_VERSION
 
6249
template<class T1, class T2, class M>
 
6250
#if BOOST_VERSION < 104601
1455
6251
typename
1456
6252
boost::proto::detail::enable_binary<
1457
6253
  field_domain,
1465
6261
operator* (const field_indirect_const<T1,M>& l, const field_basic<T2,M>& r)
1466
6262
{
1467
6263
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1468
 
    ::impl<const field_indirect_const<T1,M>&,   const field_basic<T2,M>&>() (l, r);
1469
 
}
 
6264
    ::impl<const field_indirect_const<T1,M>&, const field_basic<T2,M>&>() (l, r);
 
6265
}
 
6266
#else // BOOST_VERSION >= 104601
 
6267
typename boost::proto::detail::enable_binary< 
 
6268
  field_domain,
 
6269
  field_domain::proto_grammar,
 
6270
  boost::mpl::and_<
 
6271
    boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_basic<T2,M> > >,
 
6272
    boost::mpl::not_<
 
6273
      boost::mpl::or_<
 
6274
        boost::proto::is_extension<field_indirect_const<T1,M> >,
 
6275
        boost::proto::is_extension<field_basic<T2,M> >
 
6276
      >
 
6277
    >
 
6278
  >,
 
6279
  boost::proto::tag::multiplies,
 
6280
  field_indirect_const<T1,M> const &,
 
6281
  field_basic<T2,M> const &
 
6282
>::type /* const */
 
6283
operator* (field_indirect_const<T1,M> const &left, field_basic<T2,M> const &right)
 
6284
{
 
6285
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_indirect_const<T1,M> const &, field_basic<T2,M> const &>()(left, right);
 
6286
}
 
6287
#endif // BOOST_VERSION
1470
6288
template<class T1, class T2, class M>
 
6289
#if BOOST_VERSION < 104601
1471
6290
typename
1472
6291
boost::proto::detail::enable_binary<
1473
6292
  field_domain,
1481
6300
operator* (const field_indirect_const<T1,M>& l, const field_indirect<T2,M>& r)
1482
6301
{
1483
6302
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1484
 
    ::impl<const field_indirect_const<T1,M>&,   const field_indirect<T2,M>&>() (l, r);
1485
 
}
 
6303
    ::impl<const field_indirect_const<T1,M>&, const field_indirect<T2,M>&>() (l, r);
 
6304
}
 
6305
#else // BOOST_VERSION >= 104601
 
6306
typename boost::proto::detail::enable_binary< 
 
6307
  field_domain,
 
6308
  field_domain::proto_grammar,
 
6309
  boost::mpl::and_<
 
6310
    boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_indirect<T2,M> > >,
 
6311
    boost::mpl::not_<
 
6312
      boost::mpl::or_<
 
6313
        boost::proto::is_extension<field_indirect_const<T1,M> >,
 
6314
        boost::proto::is_extension<field_indirect<T2,M> >
 
6315
      >
 
6316
    >
 
6317
  >,
 
6318
  boost::proto::tag::multiplies,
 
6319
  field_indirect_const<T1,M> const &,
 
6320
  field_indirect<T2,M> const &
 
6321
>::type /* const */
 
6322
operator* (field_indirect_const<T1,M> const &left, field_indirect<T2,M> const &right)
 
6323
{
 
6324
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_indirect_const<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
 
6325
}
 
6326
#endif // BOOST_VERSION
1486
6327
template<class T1, class T2, class M>
 
6328
#if BOOST_VERSION < 104601
1487
6329
typename
1488
6330
boost::proto::detail::enable_binary<
1489
6331
  field_domain,
1497
6339
operator* (const field_indirect_const<T1,M>& l, const field_indirect_const<T2,M>& r)
1498
6340
{
1499
6341
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1500
 
    ::impl<const field_indirect_const<T1,M>&,   const field_indirect_const<T2,M>&>() (l, r);
1501
 
}
 
6342
    ::impl<const field_indirect_const<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
 
6343
}
 
6344
#else // BOOST_VERSION >= 104601
 
6345
typename boost::proto::detail::enable_binary< 
 
6346
  field_domain,
 
6347
  field_domain::proto_grammar,
 
6348
  boost::mpl::and_<
 
6349
    boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_indirect_const<T2,M> > >,
 
6350
    boost::mpl::not_<
 
6351
      boost::mpl::or_<
 
6352
        boost::proto::is_extension<field_indirect_const<T1,M> >,
 
6353
        boost::proto::is_extension<field_indirect_const<T2,M> >
 
6354
      >
 
6355
    >
 
6356
  >,
 
6357
  boost::proto::tag::multiplies,
 
6358
  field_indirect_const<T1,M> const &,
 
6359
  field_indirect_const<T2,M> const &
 
6360
>::type /* const */
 
6361
operator* (field_indirect_const<T1,M> const &left, field_indirect_const<T2,M> const &right)
 
6362
{
 
6363
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_indirect_const<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
 
6364
}
 
6365
#endif // BOOST_VERSION
 
6366
template<class T1, class T2, class M>
 
6367
#if BOOST_VERSION < 104601
 
6368
typename
 
6369
boost::proto::detail::enable_binary<
 
6370
  field_domain,
 
6371
  is_field<field_indirect_const<T1,M> >,
 
6372
  field_indirect_const<T1,M>,
 
6373
  is_field<field_component<T2,M> >,
 
6374
  field_component<T2,M>,
 
6375
  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6376
    ::impl<const field_indirect_const<T1,M>&,   const field_component<T2,M>&>::result_type const
 
6377
>::type
 
6378
operator* (const field_indirect_const<T1,M>& l, const field_component<T2,M>& r)
 
6379
{
 
6380
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6381
    ::impl<const field_indirect_const<T1,M>&, const field_component<T2,M>&>() (l, r);
 
6382
}
 
6383
#else // BOOST_VERSION >= 104601
 
6384
typename boost::proto::detail::enable_binary< 
 
6385
  field_domain,
 
6386
  field_domain::proto_grammar,
 
6387
  boost::mpl::and_<
 
6388
    boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_component<T2,M> > >,
 
6389
    boost::mpl::not_<
 
6390
      boost::mpl::or_<
 
6391
        boost::proto::is_extension<field_indirect_const<T1,M> >,
 
6392
        boost::proto::is_extension<field_component<T2,M> >
 
6393
      >
 
6394
    >
 
6395
  >,
 
6396
  boost::proto::tag::multiplies,
 
6397
  field_indirect_const<T1,M> const &,
 
6398
  field_component<T2,M> const &
 
6399
>::type /* const */
 
6400
operator* (field_indirect_const<T1,M> const &left, field_component<T2,M> const &right)
 
6401
{
 
6402
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_indirect_const<T1,M> const &, field_component<T2,M> const &>()(left, right);
 
6403
}
 
6404
#endif // BOOST_VERSION
 
6405
template<class T1, class T2, class M>
 
6406
#if BOOST_VERSION < 104601
 
6407
typename
 
6408
boost::proto::detail::enable_binary<
 
6409
  field_domain,
 
6410
  is_field<field_indirect_const<T1,M> >,
 
6411
  field_indirect_const<T1,M>,
 
6412
  is_field<field_component_const<T2,M> >,
 
6413
  field_component_const<T2,M>,
 
6414
  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6415
    ::impl<const field_indirect_const<T1,M>&,   const field_component_const<T2,M>&>::result_type const
 
6416
>::type
 
6417
operator* (const field_indirect_const<T1,M>& l, const field_component_const<T2,M>& r)
 
6418
{
 
6419
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6420
    ::impl<const field_indirect_const<T1,M>&, const field_component_const<T2,M>&>() (l, r);
 
6421
}
 
6422
#else // BOOST_VERSION >= 104601
 
6423
typename boost::proto::detail::enable_binary< 
 
6424
  field_domain,
 
6425
  field_domain::proto_grammar,
 
6426
  boost::mpl::and_<
 
6427
    boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_component_const<T2,M> > >,
 
6428
    boost::mpl::not_<
 
6429
      boost::mpl::or_<
 
6430
        boost::proto::is_extension<field_indirect_const<T1,M> >,
 
6431
        boost::proto::is_extension<field_component_const<T2,M> >
 
6432
      >
 
6433
    >
 
6434
  >,
 
6435
  boost::proto::tag::multiplies,
 
6436
  field_indirect_const<T1,M> const &,
 
6437
  field_component_const<T2,M> const &
 
6438
>::type /* const */
 
6439
operator* (field_indirect_const<T1,M> const &left, field_component_const<T2,M> const &right)
 
6440
{
 
6441
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_indirect_const<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
 
6442
}
 
6443
#endif // BOOST_VERSION
 
6444
template<class T1, class T2, class M>
 
6445
#if BOOST_VERSION < 104601
 
6446
typename
 
6447
boost::proto::detail::enable_binary<
 
6448
  field_domain,
 
6449
  is_field<field_component<T1,M> >,
 
6450
  field_component<T1,M>,
 
6451
  is_field<field_basic<T2,M> >,
 
6452
  field_basic<T2,M>,
 
6453
  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6454
    ::impl<const field_component<T1,M>&,   const field_basic<T2,M>&>::result_type const
 
6455
>::type
 
6456
operator* (const field_component<T1,M>& l, const field_basic<T2,M>& r)
 
6457
{
 
6458
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6459
    ::impl<const field_component<T1,M>&, const field_basic<T2,M>&>() (l, r);
 
6460
}
 
6461
#else // BOOST_VERSION >= 104601
 
6462
typename boost::proto::detail::enable_binary< 
 
6463
  field_domain,
 
6464
  field_domain::proto_grammar,
 
6465
  boost::mpl::and_<
 
6466
    boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_basic<T2,M> > >,
 
6467
    boost::mpl::not_<
 
6468
      boost::mpl::or_<
 
6469
        boost::proto::is_extension<field_component<T1,M> >,
 
6470
        boost::proto::is_extension<field_basic<T2,M> >
 
6471
      >
 
6472
    >
 
6473
  >,
 
6474
  boost::proto::tag::multiplies,
 
6475
  field_component<T1,M> const &,
 
6476
  field_basic<T2,M> const &
 
6477
>::type /* const */
 
6478
operator* (field_component<T1,M> const &left, field_basic<T2,M> const &right)
 
6479
{
 
6480
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_component<T1,M> const &, field_basic<T2,M> const &>()(left, right);
 
6481
}
 
6482
#endif // BOOST_VERSION
 
6483
template<class T1, class T2, class M>
 
6484
#if BOOST_VERSION < 104601
 
6485
typename
 
6486
boost::proto::detail::enable_binary<
 
6487
  field_domain,
 
6488
  is_field<field_component<T1,M> >,
 
6489
  field_component<T1,M>,
 
6490
  is_field<field_indirect<T2,M> >,
 
6491
  field_indirect<T2,M>,
 
6492
  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6493
    ::impl<const field_component<T1,M>&,   const field_indirect<T2,M>&>::result_type const
 
6494
>::type
 
6495
operator* (const field_component<T1,M>& l, const field_indirect<T2,M>& r)
 
6496
{
 
6497
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6498
    ::impl<const field_component<T1,M>&, const field_indirect<T2,M>&>() (l, r);
 
6499
}
 
6500
#else // BOOST_VERSION >= 104601
 
6501
typename boost::proto::detail::enable_binary< 
 
6502
  field_domain,
 
6503
  field_domain::proto_grammar,
 
6504
  boost::mpl::and_<
 
6505
    boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_indirect<T2,M> > >,
 
6506
    boost::mpl::not_<
 
6507
      boost::mpl::or_<
 
6508
        boost::proto::is_extension<field_component<T1,M> >,
 
6509
        boost::proto::is_extension<field_indirect<T2,M> >
 
6510
      >
 
6511
    >
 
6512
  >,
 
6513
  boost::proto::tag::multiplies,
 
6514
  field_component<T1,M> const &,
 
6515
  field_indirect<T2,M> const &
 
6516
>::type /* const */
 
6517
operator* (field_component<T1,M> const &left, field_indirect<T2,M> const &right)
 
6518
{
 
6519
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_component<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
 
6520
}
 
6521
#endif // BOOST_VERSION
 
6522
template<class T1, class T2, class M>
 
6523
#if BOOST_VERSION < 104601
 
6524
typename
 
6525
boost::proto::detail::enable_binary<
 
6526
  field_domain,
 
6527
  is_field<field_component<T1,M> >,
 
6528
  field_component<T1,M>,
 
6529
  is_field<field_indirect_const<T2,M> >,
 
6530
  field_indirect_const<T2,M>,
 
6531
  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6532
    ::impl<const field_component<T1,M>&,   const field_indirect_const<T2,M>&>::result_type const
 
6533
>::type
 
6534
operator* (const field_component<T1,M>& l, const field_indirect_const<T2,M>& r)
 
6535
{
 
6536
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6537
    ::impl<const field_component<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
 
6538
}
 
6539
#else // BOOST_VERSION >= 104601
 
6540
typename boost::proto::detail::enable_binary< 
 
6541
  field_domain,
 
6542
  field_domain::proto_grammar,
 
6543
  boost::mpl::and_<
 
6544
    boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_indirect_const<T2,M> > >,
 
6545
    boost::mpl::not_<
 
6546
      boost::mpl::or_<
 
6547
        boost::proto::is_extension<field_component<T1,M> >,
 
6548
        boost::proto::is_extension<field_indirect_const<T2,M> >
 
6549
      >
 
6550
    >
 
6551
  >,
 
6552
  boost::proto::tag::multiplies,
 
6553
  field_component<T1,M> const &,
 
6554
  field_indirect_const<T2,M> const &
 
6555
>::type /* const */
 
6556
operator* (field_component<T1,M> const &left, field_indirect_const<T2,M> const &right)
 
6557
{
 
6558
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_component<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
 
6559
}
 
6560
#endif // BOOST_VERSION
 
6561
template<class T1, class T2, class M>
 
6562
#if BOOST_VERSION < 104601
 
6563
typename
 
6564
boost::proto::detail::enable_binary<
 
6565
  field_domain,
 
6566
  is_field<field_component<T1,M> >,
 
6567
  field_component<T1,M>,
 
6568
  is_field<field_component<T2,M> >,
 
6569
  field_component<T2,M>,
 
6570
  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6571
    ::impl<const field_component<T1,M>&,   const field_component<T2,M>&>::result_type const
 
6572
>::type
 
6573
operator* (const field_component<T1,M>& l, const field_component<T2,M>& r)
 
6574
{
 
6575
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6576
    ::impl<const field_component<T1,M>&, const field_component<T2,M>&>() (l, r);
 
6577
}
 
6578
#else // BOOST_VERSION >= 104601
 
6579
typename boost::proto::detail::enable_binary< 
 
6580
  field_domain,
 
6581
  field_domain::proto_grammar,
 
6582
  boost::mpl::and_<
 
6583
    boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_component<T2,M> > >,
 
6584
    boost::mpl::not_<
 
6585
      boost::mpl::or_<
 
6586
        boost::proto::is_extension<field_component<T1,M> >,
 
6587
        boost::proto::is_extension<field_component<T2,M> >
 
6588
      >
 
6589
    >
 
6590
  >,
 
6591
  boost::proto::tag::multiplies,
 
6592
  field_component<T1,M> const &,
 
6593
  field_component<T2,M> const &
 
6594
>::type /* const */
 
6595
operator* (field_component<T1,M> const &left, field_component<T2,M> const &right)
 
6596
{
 
6597
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_component<T1,M> const &, field_component<T2,M> const &>()(left, right);
 
6598
}
 
6599
#endif // BOOST_VERSION
 
6600
template<class T1, class T2, class M>
 
6601
#if BOOST_VERSION < 104601
 
6602
typename
 
6603
boost::proto::detail::enable_binary<
 
6604
  field_domain,
 
6605
  is_field<field_component<T1,M> >,
 
6606
  field_component<T1,M>,
 
6607
  is_field<field_component_const<T2,M> >,
 
6608
  field_component_const<T2,M>,
 
6609
  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6610
    ::impl<const field_component<T1,M>&,   const field_component_const<T2,M>&>::result_type const
 
6611
>::type
 
6612
operator* (const field_component<T1,M>& l, const field_component_const<T2,M>& r)
 
6613
{
 
6614
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6615
    ::impl<const field_component<T1,M>&, const field_component_const<T2,M>&>() (l, r);
 
6616
}
 
6617
#else // BOOST_VERSION >= 104601
 
6618
typename boost::proto::detail::enable_binary< 
 
6619
  field_domain,
 
6620
  field_domain::proto_grammar,
 
6621
  boost::mpl::and_<
 
6622
    boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_component_const<T2,M> > >,
 
6623
    boost::mpl::not_<
 
6624
      boost::mpl::or_<
 
6625
        boost::proto::is_extension<field_component<T1,M> >,
 
6626
        boost::proto::is_extension<field_component_const<T2,M> >
 
6627
      >
 
6628
    >
 
6629
  >,
 
6630
  boost::proto::tag::multiplies,
 
6631
  field_component<T1,M> const &,
 
6632
  field_component_const<T2,M> const &
 
6633
>::type /* const */
 
6634
operator* (field_component<T1,M> const &left, field_component_const<T2,M> const &right)
 
6635
{
 
6636
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_component<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
 
6637
}
 
6638
#endif // BOOST_VERSION
 
6639
template<class T1, class T2, class M>
 
6640
#if BOOST_VERSION < 104601
 
6641
typename
 
6642
boost::proto::detail::enable_binary<
 
6643
  field_domain,
 
6644
  is_field<field_component_const<T1,M> >,
 
6645
  field_component_const<T1,M>,
 
6646
  is_field<field_basic<T2,M> >,
 
6647
  field_basic<T2,M>,
 
6648
  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6649
    ::impl<const field_component_const<T1,M>&,   const field_basic<T2,M>&>::result_type const
 
6650
>::type
 
6651
operator* (const field_component_const<T1,M>& l, const field_basic<T2,M>& r)
 
6652
{
 
6653
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6654
    ::impl<const field_component_const<T1,M>&, const field_basic<T2,M>&>() (l, r);
 
6655
}
 
6656
#else // BOOST_VERSION >= 104601
 
6657
typename boost::proto::detail::enable_binary< 
 
6658
  field_domain,
 
6659
  field_domain::proto_grammar,
 
6660
  boost::mpl::and_<
 
6661
    boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_basic<T2,M> > >,
 
6662
    boost::mpl::not_<
 
6663
      boost::mpl::or_<
 
6664
        boost::proto::is_extension<field_component_const<T1,M> >,
 
6665
        boost::proto::is_extension<field_basic<T2,M> >
 
6666
      >
 
6667
    >
 
6668
  >,
 
6669
  boost::proto::tag::multiplies,
 
6670
  field_component_const<T1,M> const &,
 
6671
  field_basic<T2,M> const &
 
6672
>::type /* const */
 
6673
operator* (field_component_const<T1,M> const &left, field_basic<T2,M> const &right)
 
6674
{
 
6675
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_component_const<T1,M> const &, field_basic<T2,M> const &>()(left, right);
 
6676
}
 
6677
#endif // BOOST_VERSION
 
6678
template<class T1, class T2, class M>
 
6679
#if BOOST_VERSION < 104601
 
6680
typename
 
6681
boost::proto::detail::enable_binary<
 
6682
  field_domain,
 
6683
  is_field<field_component_const<T1,M> >,
 
6684
  field_component_const<T1,M>,
 
6685
  is_field<field_indirect<T2,M> >,
 
6686
  field_indirect<T2,M>,
 
6687
  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6688
    ::impl<const field_component_const<T1,M>&,   const field_indirect<T2,M>&>::result_type const
 
6689
>::type
 
6690
operator* (const field_component_const<T1,M>& l, const field_indirect<T2,M>& r)
 
6691
{
 
6692
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6693
    ::impl<const field_component_const<T1,M>&, const field_indirect<T2,M>&>() (l, r);
 
6694
}
 
6695
#else // BOOST_VERSION >= 104601
 
6696
typename boost::proto::detail::enable_binary< 
 
6697
  field_domain,
 
6698
  field_domain::proto_grammar,
 
6699
  boost::mpl::and_<
 
6700
    boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_indirect<T2,M> > >,
 
6701
    boost::mpl::not_<
 
6702
      boost::mpl::or_<
 
6703
        boost::proto::is_extension<field_component_const<T1,M> >,
 
6704
        boost::proto::is_extension<field_indirect<T2,M> >
 
6705
      >
 
6706
    >
 
6707
  >,
 
6708
  boost::proto::tag::multiplies,
 
6709
  field_component_const<T1,M> const &,
 
6710
  field_indirect<T2,M> const &
 
6711
>::type /* const */
 
6712
operator* (field_component_const<T1,M> const &left, field_indirect<T2,M> const &right)
 
6713
{
 
6714
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_component_const<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
 
6715
}
 
6716
#endif // BOOST_VERSION
 
6717
template<class T1, class T2, class M>
 
6718
#if BOOST_VERSION < 104601
 
6719
typename
 
6720
boost::proto::detail::enable_binary<
 
6721
  field_domain,
 
6722
  is_field<field_component_const<T1,M> >,
 
6723
  field_component_const<T1,M>,
 
6724
  is_field<field_indirect_const<T2,M> >,
 
6725
  field_indirect_const<T2,M>,
 
6726
  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6727
    ::impl<const field_component_const<T1,M>&,   const field_indirect_const<T2,M>&>::result_type const
 
6728
>::type
 
6729
operator* (const field_component_const<T1,M>& l, const field_indirect_const<T2,M>& r)
 
6730
{
 
6731
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6732
    ::impl<const field_component_const<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
 
6733
}
 
6734
#else // BOOST_VERSION >= 104601
 
6735
typename boost::proto::detail::enable_binary< 
 
6736
  field_domain,
 
6737
  field_domain::proto_grammar,
 
6738
  boost::mpl::and_<
 
6739
    boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_indirect_const<T2,M> > >,
 
6740
    boost::mpl::not_<
 
6741
      boost::mpl::or_<
 
6742
        boost::proto::is_extension<field_component_const<T1,M> >,
 
6743
        boost::proto::is_extension<field_indirect_const<T2,M> >
 
6744
      >
 
6745
    >
 
6746
  >,
 
6747
  boost::proto::tag::multiplies,
 
6748
  field_component_const<T1,M> const &,
 
6749
  field_indirect_const<T2,M> const &
 
6750
>::type /* const */
 
6751
operator* (field_component_const<T1,M> const &left, field_indirect_const<T2,M> const &right)
 
6752
{
 
6753
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_component_const<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
 
6754
}
 
6755
#endif // BOOST_VERSION
 
6756
template<class T1, class T2, class M>
 
6757
#if BOOST_VERSION < 104601
 
6758
typename
 
6759
boost::proto::detail::enable_binary<
 
6760
  field_domain,
 
6761
  is_field<field_component_const<T1,M> >,
 
6762
  field_component_const<T1,M>,
 
6763
  is_field<field_component<T2,M> >,
 
6764
  field_component<T2,M>,
 
6765
  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6766
    ::impl<const field_component_const<T1,M>&,   const field_component<T2,M>&>::result_type const
 
6767
>::type
 
6768
operator* (const field_component_const<T1,M>& l, const field_component<T2,M>& r)
 
6769
{
 
6770
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6771
    ::impl<const field_component_const<T1,M>&, const field_component<T2,M>&>() (l, r);
 
6772
}
 
6773
#else // BOOST_VERSION >= 104601
 
6774
typename boost::proto::detail::enable_binary< 
 
6775
  field_domain,
 
6776
  field_domain::proto_grammar,
 
6777
  boost::mpl::and_<
 
6778
    boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_component<T2,M> > >,
 
6779
    boost::mpl::not_<
 
6780
      boost::mpl::or_<
 
6781
        boost::proto::is_extension<field_component_const<T1,M> >,
 
6782
        boost::proto::is_extension<field_component<T2,M> >
 
6783
      >
 
6784
    >
 
6785
  >,
 
6786
  boost::proto::tag::multiplies,
 
6787
  field_component_const<T1,M> const &,
 
6788
  field_component<T2,M> const &
 
6789
>::type /* const */
 
6790
operator* (field_component_const<T1,M> const &left, field_component<T2,M> const &right)
 
6791
{
 
6792
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_component_const<T1,M> const &, field_component<T2,M> const &>()(left, right);
 
6793
}
 
6794
#endif // BOOST_VERSION
 
6795
template<class T1, class T2, class M>
 
6796
#if BOOST_VERSION < 104601
 
6797
typename
 
6798
boost::proto::detail::enable_binary<
 
6799
  field_domain,
 
6800
  is_field<field_component_const<T1,M> >,
 
6801
  field_component_const<T1,M>,
 
6802
  is_field<field_component_const<T2,M> >,
 
6803
  field_component_const<T2,M>,
 
6804
  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6805
    ::impl<const field_component_const<T1,M>&,   const field_component_const<T2,M>&>::result_type const
 
6806
>::type
 
6807
operator* (const field_component_const<T1,M>& l, const field_component_const<T2,M>& r)
 
6808
{
 
6809
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
6810
    ::impl<const field_component_const<T1,M>&, const field_component_const<T2,M>&>() (l, r);
 
6811
}
 
6812
#else // BOOST_VERSION >= 104601
 
6813
typename boost::proto::detail::enable_binary< 
 
6814
  field_domain,
 
6815
  field_domain::proto_grammar,
 
6816
  boost::mpl::and_<
 
6817
    boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_component_const<T2,M> > >,
 
6818
    boost::mpl::not_<
 
6819
      boost::mpl::or_<
 
6820
        boost::proto::is_extension<field_component_const<T1,M> >,
 
6821
        boost::proto::is_extension<field_component_const<T2,M> >
 
6822
      >
 
6823
    >
 
6824
  >,
 
6825
  boost::proto::tag::multiplies,
 
6826
  field_component_const<T1,M> const &,
 
6827
  field_component_const<T2,M> const &
 
6828
>::type /* const */
 
6829
operator* (field_component_const<T1,M> const &left, field_component_const<T2,M> const &right)
 
6830
{
 
6831
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_component_const<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
 
6832
}
 
6833
#endif // BOOST_VERSION
1502
6834
template<class Expr>
 
6835
#if BOOST_VERSION < 104601
1503
6836
typename
1504
6837
boost::proto::detail::enable_binary<
1505
6838
  field_domain,
1513
6846
operator* (const int& l, const field_expr<Expr>& r)
1514
6847
{
1515
6848
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1516
 
    ::impl<const int&,   const field_expr<Expr>&>() (l, r);
1517
 
}
 
6849
    ::impl<const int&, const field_expr<Expr>&>() (l, r);
 
6850
}
 
6851
#else // BOOST_VERSION >= 104601
 
6852
typename boost::proto::detail::enable_binary< 
 
6853
  field_domain,
 
6854
  field_domain::proto_grammar,
 
6855
  boost::mpl::and_<
 
6856
    boost::mpl::or_<is_field<int >, is_field<field_expr<Expr> > >,
 
6857
    boost::mpl::not_<
 
6858
      boost::mpl::or_<
 
6859
        boost::proto::is_extension<int >,
 
6860
        boost::proto::is_extension<field_expr<Expr> >
 
6861
      >
 
6862
    >
 
6863
  >,
 
6864
  boost::proto::tag::multiplies,
 
6865
  int const &,
 
6866
  field_expr<Expr> const &
 
6867
>::type /* const */
 
6868
operator* (int const &left, field_expr<Expr> const &right)
 
6869
{
 
6870
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, int const &, field_expr<Expr> const &>()(left, right);
 
6871
}
 
6872
#endif // BOOST_VERSION
1518
6873
template<class Expr>
 
6874
#if BOOST_VERSION < 104601
1519
6875
typename
1520
6876
boost::proto::detail::enable_binary<
1521
6877
  field_domain,
1529
6885
operator* (const field_expr<Expr>& l, const int& r)
1530
6886
{
1531
6887
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1532
 
    ::impl<const field_expr<Expr>&,   const int&>() (l, r);
1533
 
}
 
6888
    ::impl<const field_expr<Expr>&, const int&>() (l, r);
 
6889
}
 
6890
#else // BOOST_VERSION >= 104601
 
6891
typename boost::proto::detail::enable_binary< 
 
6892
  field_domain,
 
6893
  field_domain::proto_grammar,
 
6894
  boost::mpl::and_<
 
6895
    boost::mpl::or_<is_field<field_expr<Expr> >, is_field<int > >,
 
6896
    boost::mpl::not_<
 
6897
      boost::mpl::or_<
 
6898
        boost::proto::is_extension<field_expr<Expr> >,
 
6899
        boost::proto::is_extension<int >
 
6900
      >
 
6901
    >
 
6902
  >,
 
6903
  boost::proto::tag::multiplies,
 
6904
  field_expr<Expr> const &,
 
6905
  int const &
 
6906
>::type /* const */
 
6907
operator* (field_expr<Expr> const &left, int const &right)
 
6908
{
 
6909
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_expr<Expr> const &, int const &>()(left, right);
 
6910
}
 
6911
#endif // BOOST_VERSION
1534
6912
template<class T, class Expr>
 
6913
#if BOOST_VERSION < 104601
1535
6914
typename
1536
6915
boost::proto::detail::enable_binary<
1537
6916
  field_domain,
1545
6924
operator* (const T& l, const field_expr<Expr>& r)
1546
6925
{
1547
6926
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1548
 
    ::impl<const T&,   const field_expr<Expr>&>() (l, r);
1549
 
}
 
6927
    ::impl<const T&, const field_expr<Expr>&>() (l, r);
 
6928
}
 
6929
#else // BOOST_VERSION >= 104601
 
6930
typename boost::proto::detail::enable_binary< 
 
6931
  field_domain,
 
6932
  field_domain::proto_grammar,
 
6933
  boost::mpl::and_<
 
6934
    boost::mpl::or_<is_field<T >, is_field<field_expr<Expr> > >,
 
6935
    boost::mpl::not_<
 
6936
      boost::mpl::or_<
 
6937
        boost::proto::is_extension<T >,
 
6938
        boost::proto::is_extension<field_expr<Expr> >
 
6939
      >
 
6940
    >
 
6941
  >,
 
6942
  boost::proto::tag::multiplies,
 
6943
  T const &,
 
6944
  field_expr<Expr> const &
 
6945
>::type /* const */
 
6946
operator* (T const &left, field_expr<Expr> const &right)
 
6947
{
 
6948
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, T const &, field_expr<Expr> const &>()(left, right);
 
6949
}
 
6950
#endif // BOOST_VERSION
1550
6951
template<class T, class Expr>
 
6952
#if BOOST_VERSION < 104601
1551
6953
typename
1552
6954
boost::proto::detail::enable_binary<
1553
6955
  field_domain,
1561
6963
operator* (const field_expr<Expr>& l, const T& r)
1562
6964
{
1563
6965
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1564
 
    ::impl<const field_expr<Expr>&,   const T&>() (l, r);
1565
 
}
 
6966
    ::impl<const field_expr<Expr>&, const T&>() (l, r);
 
6967
}
 
6968
#else // BOOST_VERSION >= 104601
 
6969
typename boost::proto::detail::enable_binary< 
 
6970
  field_domain,
 
6971
  field_domain::proto_grammar,
 
6972
  boost::mpl::and_<
 
6973
    boost::mpl::or_<is_field<field_expr<Expr> >, is_field<T > >,
 
6974
    boost::mpl::not_<
 
6975
      boost::mpl::or_<
 
6976
        boost::proto::is_extension<field_expr<Expr> >,
 
6977
        boost::proto::is_extension<T >
 
6978
      >
 
6979
    >
 
6980
  >,
 
6981
  boost::proto::tag::multiplies,
 
6982
  field_expr<Expr> const &,
 
6983
  T const &
 
6984
>::type /* const */
 
6985
operator* (field_expr<Expr> const &left, T const &right)
 
6986
{
 
6987
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_expr<Expr> const &, T const &>()(left, right);
 
6988
}
 
6989
#endif // BOOST_VERSION
1566
6990
template<class T, class M, class Expr>
 
6991
#if BOOST_VERSION < 104601
1567
6992
typename
1568
6993
boost::proto::detail::enable_binary<
1569
6994
  field_domain,
1577
7002
operator* (const field_basic<T,M>& l, const field_expr<Expr>& r)
1578
7003
{
1579
7004
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1580
 
    ::impl<const field_basic<T,M>&,   const field_expr<Expr>&>() (l, r);
1581
 
}
 
7005
    ::impl<const field_basic<T,M>&, const field_expr<Expr>&>() (l, r);
 
7006
}
 
7007
#else // BOOST_VERSION >= 104601
 
7008
typename boost::proto::detail::enable_binary< 
 
7009
  field_domain,
 
7010
  field_domain::proto_grammar,
 
7011
  boost::mpl::and_<
 
7012
    boost::mpl::or_<is_field<field_basic<T,M> >, is_field<field_expr<Expr> > >,
 
7013
    boost::mpl::not_<
 
7014
      boost::mpl::or_<
 
7015
        boost::proto::is_extension<field_basic<T,M> >,
 
7016
        boost::proto::is_extension<field_expr<Expr> >
 
7017
      >
 
7018
    >
 
7019
  >,
 
7020
  boost::proto::tag::multiplies,
 
7021
  field_basic<T,M> const &,
 
7022
  field_expr<Expr> const &
 
7023
>::type /* const */
 
7024
operator* (field_basic<T,M> const &left, field_expr<Expr> const &right)
 
7025
{
 
7026
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_basic<T,M> const &, field_expr<Expr> const &>()(left, right);
 
7027
}
 
7028
#endif // BOOST_VERSION
1582
7029
template<class T, class M, class Expr>
 
7030
#if BOOST_VERSION < 104601
1583
7031
typename
1584
7032
boost::proto::detail::enable_binary<
1585
7033
  field_domain,
1593
7041
operator* (const field_expr<Expr>& l, const field_basic<T,M>& r)
1594
7042
{
1595
7043
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1596
 
    ::impl<const field_expr<Expr>&,   const field_basic<T,M>&>() (l, r);
1597
 
}
 
7044
    ::impl<const field_expr<Expr>&, const field_basic<T,M>&>() (l, r);
 
7045
}
 
7046
#else // BOOST_VERSION >= 104601
 
7047
typename boost::proto::detail::enable_binary< 
 
7048
  field_domain,
 
7049
  field_domain::proto_grammar,
 
7050
  boost::mpl::and_<
 
7051
    boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_basic<T,M> > >,
 
7052
    boost::mpl::not_<
 
7053
      boost::mpl::or_<
 
7054
        boost::proto::is_extension<field_expr<Expr> >,
 
7055
        boost::proto::is_extension<field_basic<T,M> >
 
7056
      >
 
7057
    >
 
7058
  >,
 
7059
  boost::proto::tag::multiplies,
 
7060
  field_expr<Expr> const &,
 
7061
  field_basic<T,M> const &
 
7062
>::type /* const */
 
7063
operator* (field_expr<Expr> const &left, field_basic<T,M> const &right)
 
7064
{
 
7065
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_expr<Expr> const &, field_basic<T,M> const &>()(left, right);
 
7066
}
 
7067
#endif // BOOST_VERSION
1598
7068
template<class T, class M, class Expr>
 
7069
#if BOOST_VERSION < 104601
1599
7070
typename
1600
7071
boost::proto::detail::enable_binary<
1601
7072
  field_domain,
1609
7080
operator* (const field_indirect<T,M>& l, const field_expr<Expr>& r)
1610
7081
{
1611
7082
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1612
 
    ::impl<const field_indirect<T,M>&,   const field_expr<Expr>&>() (l, r);
1613
 
}
 
7083
    ::impl<const field_indirect<T,M>&, const field_expr<Expr>&>() (l, r);
 
7084
}
 
7085
#else // BOOST_VERSION >= 104601
 
7086
typename boost::proto::detail::enable_binary< 
 
7087
  field_domain,
 
7088
  field_domain::proto_grammar,
 
7089
  boost::mpl::and_<
 
7090
    boost::mpl::or_<is_field<field_indirect<T,M> >, is_field<field_expr<Expr> > >,
 
7091
    boost::mpl::not_<
 
7092
      boost::mpl::or_<
 
7093
        boost::proto::is_extension<field_indirect<T,M> >,
 
7094
        boost::proto::is_extension<field_expr<Expr> >
 
7095
      >
 
7096
    >
 
7097
  >,
 
7098
  boost::proto::tag::multiplies,
 
7099
  field_indirect<T,M> const &,
 
7100
  field_expr<Expr> const &
 
7101
>::type /* const */
 
7102
operator* (field_indirect<T,M> const &left, field_expr<Expr> const &right)
 
7103
{
 
7104
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_indirect<T,M> const &, field_expr<Expr> const &>()(left, right);
 
7105
}
 
7106
#endif // BOOST_VERSION
1614
7107
template<class T, class M, class Expr>
 
7108
#if BOOST_VERSION < 104601
1615
7109
typename
1616
7110
boost::proto::detail::enable_binary<
1617
7111
  field_domain,
1625
7119
operator* (const field_expr<Expr>& l, const field_indirect<T,M>& r)
1626
7120
{
1627
7121
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1628
 
    ::impl<const field_expr<Expr>&,   const field_indirect<T,M>&>() (l, r);
1629
 
}
 
7122
    ::impl<const field_expr<Expr>&, const field_indirect<T,M>&>() (l, r);
 
7123
}
 
7124
#else // BOOST_VERSION >= 104601
 
7125
typename boost::proto::detail::enable_binary< 
 
7126
  field_domain,
 
7127
  field_domain::proto_grammar,
 
7128
  boost::mpl::and_<
 
7129
    boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_indirect<T,M> > >,
 
7130
    boost::mpl::not_<
 
7131
      boost::mpl::or_<
 
7132
        boost::proto::is_extension<field_expr<Expr> >,
 
7133
        boost::proto::is_extension<field_indirect<T,M> >
 
7134
      >
 
7135
    >
 
7136
  >,
 
7137
  boost::proto::tag::multiplies,
 
7138
  field_expr<Expr> const &,
 
7139
  field_indirect<T,M> const &
 
7140
>::type /* const */
 
7141
operator* (field_expr<Expr> const &left, field_indirect<T,M> const &right)
 
7142
{
 
7143
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_expr<Expr> const &, field_indirect<T,M> const &>()(left, right);
 
7144
}
 
7145
#endif // BOOST_VERSION
1630
7146
template<class T, class M, class Expr>
 
7147
#if BOOST_VERSION < 104601
1631
7148
typename
1632
7149
boost::proto::detail::enable_binary<
1633
7150
  field_domain,
1641
7158
operator* (const field_indirect_const<T,M>& l, const field_expr<Expr>& r)
1642
7159
{
1643
7160
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1644
 
    ::impl<const field_indirect_const<T,M>&,   const field_expr<Expr>&>() (l, r);
1645
 
}
 
7161
    ::impl<const field_indirect_const<T,M>&, const field_expr<Expr>&>() (l, r);
 
7162
}
 
7163
#else // BOOST_VERSION >= 104601
 
7164
typename boost::proto::detail::enable_binary< 
 
7165
  field_domain,
 
7166
  field_domain::proto_grammar,
 
7167
  boost::mpl::and_<
 
7168
    boost::mpl::or_<is_field<field_indirect_const<T,M> >, is_field<field_expr<Expr> > >,
 
7169
    boost::mpl::not_<
 
7170
      boost::mpl::or_<
 
7171
        boost::proto::is_extension<field_indirect_const<T,M> >,
 
7172
        boost::proto::is_extension<field_expr<Expr> >
 
7173
      >
 
7174
    >
 
7175
  >,
 
7176
  boost::proto::tag::multiplies,
 
7177
  field_indirect_const<T,M> const &,
 
7178
  field_expr<Expr> const &
 
7179
>::type /* const */
 
7180
operator* (field_indirect_const<T,M> const &left, field_expr<Expr> const &right)
 
7181
{
 
7182
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_indirect_const<T,M> const &, field_expr<Expr> const &>()(left, right);
 
7183
}
 
7184
#endif // BOOST_VERSION
1646
7185
template<class T, class M, class Expr>
 
7186
#if BOOST_VERSION < 104601
1647
7187
typename
1648
7188
boost::proto::detail::enable_binary<
1649
7189
  field_domain,
1657
7197
operator* (const field_expr<Expr>& l, const field_indirect_const<T,M>& r)
1658
7198
{
1659
7199
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1660
 
    ::impl<const field_expr<Expr>&,   const field_indirect_const<T,M>&>() (l, r);
1661
 
}
 
7200
    ::impl<const field_expr<Expr>&, const field_indirect_const<T,M>&>() (l, r);
 
7201
}
 
7202
#else // BOOST_VERSION >= 104601
 
7203
typename boost::proto::detail::enable_binary< 
 
7204
  field_domain,
 
7205
  field_domain::proto_grammar,
 
7206
  boost::mpl::and_<
 
7207
    boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_indirect_const<T,M> > >,
 
7208
    boost::mpl::not_<
 
7209
      boost::mpl::or_<
 
7210
        boost::proto::is_extension<field_expr<Expr> >,
 
7211
        boost::proto::is_extension<field_indirect_const<T,M> >
 
7212
      >
 
7213
    >
 
7214
  >,
 
7215
  boost::proto::tag::multiplies,
 
7216
  field_expr<Expr> const &,
 
7217
  field_indirect_const<T,M> const &
 
7218
>::type /* const */
 
7219
operator* (field_expr<Expr> const &left, field_indirect_const<T,M> const &right)
 
7220
{
 
7221
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_expr<Expr> const &, field_indirect_const<T,M> const &>()(left, right);
 
7222
}
 
7223
#endif // BOOST_VERSION
 
7224
template<class T, class M, class Expr>
 
7225
#if BOOST_VERSION < 104601
 
7226
typename
 
7227
boost::proto::detail::enable_binary<
 
7228
  field_domain,
 
7229
  is_field<field_component<T,M> >,
 
7230
  field_component<T,M>,
 
7231
  is_field<field_expr<Expr> >,
 
7232
  field_expr<Expr>,
 
7233
  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
7234
    ::impl<const field_component<T,M>&,   const field_expr<Expr>&>::result_type const
 
7235
>::type
 
7236
operator* (const field_component<T,M>& l, const field_expr<Expr>& r)
 
7237
{
 
7238
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
7239
    ::impl<const field_component<T,M>&, const field_expr<Expr>&>() (l, r);
 
7240
}
 
7241
#else // BOOST_VERSION >= 104601
 
7242
typename boost::proto::detail::enable_binary< 
 
7243
  field_domain,
 
7244
  field_domain::proto_grammar,
 
7245
  boost::mpl::and_<
 
7246
    boost::mpl::or_<is_field<field_component<T,M> >, is_field<field_expr<Expr> > >,
 
7247
    boost::mpl::not_<
 
7248
      boost::mpl::or_<
 
7249
        boost::proto::is_extension<field_component<T,M> >,
 
7250
        boost::proto::is_extension<field_expr<Expr> >
 
7251
      >
 
7252
    >
 
7253
  >,
 
7254
  boost::proto::tag::multiplies,
 
7255
  field_component<T,M> const &,
 
7256
  field_expr<Expr> const &
 
7257
>::type /* const */
 
7258
operator* (field_component<T,M> const &left, field_expr<Expr> const &right)
 
7259
{
 
7260
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_component<T,M> const &, field_expr<Expr> const &>()(left, right);
 
7261
}
 
7262
#endif // BOOST_VERSION
 
7263
template<class T, class M, class Expr>
 
7264
#if BOOST_VERSION < 104601
 
7265
typename
 
7266
boost::proto::detail::enable_binary<
 
7267
  field_domain,
 
7268
  is_field<field_expr<Expr> >,
 
7269
  field_expr<Expr>,
 
7270
  is_field<field_component<T,M> >,
 
7271
  field_component<T,M>,
 
7272
  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
7273
    ::impl<const field_expr<Expr>&,   const field_component<T,M>&>::result_type const
 
7274
>::type
 
7275
operator* (const field_expr<Expr>& l, const field_component<T,M>& r)
 
7276
{
 
7277
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
7278
    ::impl<const field_expr<Expr>&, const field_component<T,M>&>() (l, r);
 
7279
}
 
7280
#else // BOOST_VERSION >= 104601
 
7281
typename boost::proto::detail::enable_binary< 
 
7282
  field_domain,
 
7283
  field_domain::proto_grammar,
 
7284
  boost::mpl::and_<
 
7285
    boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_component<T,M> > >,
 
7286
    boost::mpl::not_<
 
7287
      boost::mpl::or_<
 
7288
        boost::proto::is_extension<field_expr<Expr> >,
 
7289
        boost::proto::is_extension<field_component<T,M> >
 
7290
      >
 
7291
    >
 
7292
  >,
 
7293
  boost::proto::tag::multiplies,
 
7294
  field_expr<Expr> const &,
 
7295
  field_component<T,M> const &
 
7296
>::type /* const */
 
7297
operator* (field_expr<Expr> const &left, field_component<T,M> const &right)
 
7298
{
 
7299
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_expr<Expr> const &, field_component<T,M> const &>()(left, right);
 
7300
}
 
7301
#endif // BOOST_VERSION
 
7302
template<class T, class M, class Expr>
 
7303
#if BOOST_VERSION < 104601
 
7304
typename
 
7305
boost::proto::detail::enable_binary<
 
7306
  field_domain,
 
7307
  is_field<field_component_const<T,M> >,
 
7308
  field_component_const<T,M>,
 
7309
  is_field<field_expr<Expr> >,
 
7310
  field_expr<Expr>,
 
7311
  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
7312
    ::impl<const field_component_const<T,M>&,   const field_expr<Expr>&>::result_type const
 
7313
>::type
 
7314
operator* (const field_component_const<T,M>& l, const field_expr<Expr>& r)
 
7315
{
 
7316
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
7317
    ::impl<const field_component_const<T,M>&, const field_expr<Expr>&>() (l, r);
 
7318
}
 
7319
#else // BOOST_VERSION >= 104601
 
7320
typename boost::proto::detail::enable_binary< 
 
7321
  field_domain,
 
7322
  field_domain::proto_grammar,
 
7323
  boost::mpl::and_<
 
7324
    boost::mpl::or_<is_field<field_component_const<T,M> >, is_field<field_expr<Expr> > >,
 
7325
    boost::mpl::not_<
 
7326
      boost::mpl::or_<
 
7327
        boost::proto::is_extension<field_component_const<T,M> >,
 
7328
        boost::proto::is_extension<field_expr<Expr> >
 
7329
      >
 
7330
    >
 
7331
  >,
 
7332
  boost::proto::tag::multiplies,
 
7333
  field_component_const<T,M> const &,
 
7334
  field_expr<Expr> const &
 
7335
>::type /* const */
 
7336
operator* (field_component_const<T,M> const &left, field_expr<Expr> const &right)
 
7337
{
 
7338
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_component_const<T,M> const &, field_expr<Expr> const &>()(left, right);
 
7339
}
 
7340
#endif // BOOST_VERSION
 
7341
template<class T, class M, class Expr>
 
7342
#if BOOST_VERSION < 104601
 
7343
typename
 
7344
boost::proto::detail::enable_binary<
 
7345
  field_domain,
 
7346
  is_field<field_expr<Expr> >,
 
7347
  field_expr<Expr>,
 
7348
  is_field<field_component_const<T,M> >,
 
7349
  field_component_const<T,M>,
 
7350
  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
7351
    ::impl<const field_expr<Expr>&,   const field_component_const<T,M>&>::result_type const
 
7352
>::type
 
7353
operator* (const field_expr<Expr>& l, const field_component_const<T,M>& r)
 
7354
{
 
7355
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
 
7356
    ::impl<const field_expr<Expr>&, const field_component_const<T,M>&>() (l, r);
 
7357
}
 
7358
#else // BOOST_VERSION >= 104601
 
7359
typename boost::proto::detail::enable_binary< 
 
7360
  field_domain,
 
7361
  field_domain::proto_grammar,
 
7362
  boost::mpl::and_<
 
7363
    boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_component_const<T,M> > >,
 
7364
    boost::mpl::not_<
 
7365
      boost::mpl::or_<
 
7366
        boost::proto::is_extension<field_expr<Expr> >,
 
7367
        boost::proto::is_extension<field_component_const<T,M> >
 
7368
      >
 
7369
    >
 
7370
  >,
 
7371
  boost::proto::tag::multiplies,
 
7372
  field_expr<Expr> const &,
 
7373
  field_component_const<T,M> const &
 
7374
>::type /* const */
 
7375
operator* (field_expr<Expr> const &left, field_component_const<T,M> const &right)
 
7376
{
 
7377
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_expr<Expr> const &, field_component_const<T,M> const &>()(left, right);
 
7378
}
 
7379
#endif // BOOST_VERSION
1662
7380
template<class Expr1, class Expr2>
 
7381
#if BOOST_VERSION < 104601
1663
7382
typename
1664
7383
boost::proto::detail::enable_binary<
1665
7384
  field_domain,
1673
7392
operator* (const field_expr<Expr1>& l, const field_expr<Expr2>& r)
1674
7393
{
1675
7394
  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
1676
 
    ::impl<const field_expr<Expr1>&,   const field_expr<Expr2>&>() (l, r);
1677
 
}
 
7395
    ::impl<const field_expr<Expr1>&, const field_expr<Expr2>&>() (l, r);
 
7396
}
 
7397
#else // BOOST_VERSION >= 104601
 
7398
typename boost::proto::detail::enable_binary< 
 
7399
  field_domain,
 
7400
  field_domain::proto_grammar,
 
7401
  boost::mpl::and_<
 
7402
    boost::mpl::or_<is_field<field_expr<Expr1> >, is_field<field_expr<Expr2> > >,
 
7403
    boost::mpl::not_<
 
7404
      boost::mpl::or_<
 
7405
        boost::proto::is_extension<field_expr<Expr1> >,
 
7406
        boost::proto::is_extension<field_expr<Expr2> >
 
7407
      >
 
7408
    >
 
7409
  >,
 
7410
  boost::proto::tag::multiplies,
 
7411
  field_expr<Expr1> const &,
 
7412
  field_expr<Expr2> const &
 
7413
>::type /* const */
 
7414
operator* (field_expr<Expr1> const &left, field_expr<Expr2> const &right)
 
7415
{
 
7416
  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_expr<Expr1> const &, field_expr<Expr2> const &>()(left, right);
 
7417
}
 
7418
#endif // BOOST_VERSION
1678
7419
template<class T, class M>
 
7420
#if BOOST_VERSION < 104601
1679
7421
typename
1680
7422
boost::proto::detail::enable_binary<
1681
7423
  field_domain,
1689
7431
operator/ (const int& l, const field_basic<T,M>& r)
1690
7432
{
1691
7433
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
1692
 
    ::impl<const int&,   const field_basic<T,M>&>() (l, r);
1693
 
}
 
7434
    ::impl<const int&, const field_basic<T,M>&>() (l, r);
 
7435
}
 
7436
#else // BOOST_VERSION >= 104601
 
7437
typename boost::proto::detail::enable_binary< 
 
7438
  field_domain,
 
7439
  field_domain::proto_grammar,
 
7440
  boost::mpl::and_<
 
7441
    boost::mpl::or_<is_field<int >, is_field<field_basic<T,M> > >,
 
7442
    boost::mpl::not_<
 
7443
      boost::mpl::or_<
 
7444
        boost::proto::is_extension<int >,
 
7445
        boost::proto::is_extension<field_basic<T,M> >
 
7446
      >
 
7447
    >
 
7448
  >,
 
7449
  boost::proto::tag::divides,
 
7450
  int const &,
 
7451
  field_basic<T,M> const &
 
7452
>::type /* const */
 
7453
operator/ (int const &left, field_basic<T,M> const &right)
 
7454
{
 
7455
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, int const &, field_basic<T,M> const &>()(left, right);
 
7456
}
 
7457
#endif // BOOST_VERSION
1694
7458
template<class T, class M>
 
7459
#if BOOST_VERSION < 104601
1695
7460
typename
1696
7461
boost::proto::detail::enable_binary<
1697
7462
  field_domain,
1705
7470
operator/ (const T& l, const field_basic<T,M>& r)
1706
7471
{
1707
7472
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
1708
 
    ::impl<const T&,   const field_basic<T,M>&>() (l, r);
1709
 
}
 
7473
    ::impl<const T&, const field_basic<T,M>&>() (l, r);
 
7474
}
 
7475
#else // BOOST_VERSION >= 104601
 
7476
typename boost::proto::detail::enable_binary< 
 
7477
  field_domain,
 
7478
  field_domain::proto_grammar,
 
7479
  boost::mpl::and_<
 
7480
    boost::mpl::or_<is_field<T >, is_field<field_basic<T,M> > >,
 
7481
    boost::mpl::not_<
 
7482
      boost::mpl::or_<
 
7483
        boost::proto::is_extension<T >,
 
7484
        boost::proto::is_extension<field_basic<T,M> >
 
7485
      >
 
7486
    >
 
7487
  >,
 
7488
  boost::proto::tag::divides,
 
7489
  T const &,
 
7490
  field_basic<T,M> const &
 
7491
>::type /* const */
 
7492
operator/ (T const &left, field_basic<T,M> const &right)
 
7493
{
 
7494
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, T const &, field_basic<T,M> const &>()(left, right);
 
7495
}
 
7496
#endif // BOOST_VERSION
1710
7497
template<class T, class M>
 
7498
#if BOOST_VERSION < 104601
1711
7499
typename
1712
7500
boost::proto::detail::enable_binary<
1713
7501
  field_domain,
1721
7509
operator/ (const int& l, const field_indirect<T,M>& r)
1722
7510
{
1723
7511
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
1724
 
    ::impl<const int&,   const field_indirect<T,M>&>() (l, r);
1725
 
}
 
7512
    ::impl<const int&, const field_indirect<T,M>&>() (l, r);
 
7513
}
 
7514
#else // BOOST_VERSION >= 104601
 
7515
typename boost::proto::detail::enable_binary< 
 
7516
  field_domain,
 
7517
  field_domain::proto_grammar,
 
7518
  boost::mpl::and_<
 
7519
    boost::mpl::or_<is_field<int >, is_field<field_indirect<T,M> > >,
 
7520
    boost::mpl::not_<
 
7521
      boost::mpl::or_<
 
7522
        boost::proto::is_extension<int >,
 
7523
        boost::proto::is_extension<field_indirect<T,M> >
 
7524
      >
 
7525
    >
 
7526
  >,
 
7527
  boost::proto::tag::divides,
 
7528
  int const &,
 
7529
  field_indirect<T,M> const &
 
7530
>::type /* const */
 
7531
operator/ (int const &left, field_indirect<T,M> const &right)
 
7532
{
 
7533
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, int const &, field_indirect<T,M> const &>()(left, right);
 
7534
}
 
7535
#endif // BOOST_VERSION
1726
7536
template<class T, class M>
 
7537
#if BOOST_VERSION < 104601
1727
7538
typename
1728
7539
boost::proto::detail::enable_binary<
1729
7540
  field_domain,
1737
7548
operator/ (const T& l, const field_indirect<T,M>& r)
1738
7549
{
1739
7550
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
1740
 
    ::impl<const T&,   const field_indirect<T,M>&>() (l, r);
1741
 
}
 
7551
    ::impl<const T&, const field_indirect<T,M>&>() (l, r);
 
7552
}
 
7553
#else // BOOST_VERSION >= 104601
 
7554
typename boost::proto::detail::enable_binary< 
 
7555
  field_domain,
 
7556
  field_domain::proto_grammar,
 
7557
  boost::mpl::and_<
 
7558
    boost::mpl::or_<is_field<T >, is_field<field_indirect<T,M> > >,
 
7559
    boost::mpl::not_<
 
7560
      boost::mpl::or_<
 
7561
        boost::proto::is_extension<T >,
 
7562
        boost::proto::is_extension<field_indirect<T,M> >
 
7563
      >
 
7564
    >
 
7565
  >,
 
7566
  boost::proto::tag::divides,
 
7567
  T const &,
 
7568
  field_indirect<T,M> const &
 
7569
>::type /* const */
 
7570
operator/ (T const &left, field_indirect<T,M> const &right)
 
7571
{
 
7572
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, T const &, field_indirect<T,M> const &>()(left, right);
 
7573
}
 
7574
#endif // BOOST_VERSION
1742
7575
template<class T, class M>
 
7576
#if BOOST_VERSION < 104601
1743
7577
typename
1744
7578
boost::proto::detail::enable_binary<
1745
7579
  field_domain,
1753
7587
operator/ (const int& l, const field_indirect_const<T,M>& r)
1754
7588
{
1755
7589
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
1756
 
    ::impl<const int&,   const field_indirect_const<T,M>&>() (l, r);
1757
 
}
 
7590
    ::impl<const int&, const field_indirect_const<T,M>&>() (l, r);
 
7591
}
 
7592
#else // BOOST_VERSION >= 104601
 
7593
typename boost::proto::detail::enable_binary< 
 
7594
  field_domain,
 
7595
  field_domain::proto_grammar,
 
7596
  boost::mpl::and_<
 
7597
    boost::mpl::or_<is_field<int >, is_field<field_indirect_const<T,M> > >,
 
7598
    boost::mpl::not_<
 
7599
      boost::mpl::or_<
 
7600
        boost::proto::is_extension<int >,
 
7601
        boost::proto::is_extension<field_indirect_const<T,M> >
 
7602
      >
 
7603
    >
 
7604
  >,
 
7605
  boost::proto::tag::divides,
 
7606
  int const &,
 
7607
  field_indirect_const<T,M> const &
 
7608
>::type /* const */
 
7609
operator/ (int const &left, field_indirect_const<T,M> const &right)
 
7610
{
 
7611
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, int const &, field_indirect_const<T,M> const &>()(left, right);
 
7612
}
 
7613
#endif // BOOST_VERSION
1758
7614
template<class T, class M>
 
7615
#if BOOST_VERSION < 104601
1759
7616
typename
1760
7617
boost::proto::detail::enable_binary<
1761
7618
  field_domain,
1769
7626
operator/ (const T& l, const field_indirect_const<T,M>& r)
1770
7627
{
1771
7628
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
1772
 
    ::impl<const T&,   const field_indirect_const<T,M>&>() (l, r);
1773
 
}
1774
 
template<class T, class M>
 
7629
    ::impl<const T&, const field_indirect_const<T,M>&>() (l, r);
 
7630
}
 
7631
#else // BOOST_VERSION >= 104601
 
7632
typename boost::proto::detail::enable_binary< 
 
7633
  field_domain,
 
7634
  field_domain::proto_grammar,
 
7635
  boost::mpl::and_<
 
7636
    boost::mpl::or_<is_field<T >, is_field<field_indirect_const<T,M> > >,
 
7637
    boost::mpl::not_<
 
7638
      boost::mpl::or_<
 
7639
        boost::proto::is_extension<T >,
 
7640
        boost::proto::is_extension<field_indirect_const<T,M> >
 
7641
      >
 
7642
    >
 
7643
  >,
 
7644
  boost::proto::tag::divides,
 
7645
  T const &,
 
7646
  field_indirect_const<T,M> const &
 
7647
>::type /* const */
 
7648
operator/ (T const &left, field_indirect_const<T,M> const &right)
 
7649
{
 
7650
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, T const &, field_indirect_const<T,M> const &>()(left, right);
 
7651
}
 
7652
#endif // BOOST_VERSION
 
7653
template<class T, class M>
 
7654
#if BOOST_VERSION < 104601
 
7655
typename
 
7656
boost::proto::detail::enable_binary<
 
7657
  field_domain,
 
7658
  is_field<int >,
 
7659
  int,
 
7660
  is_field<field_component<T,M> >,
 
7661
  field_component<T,M>,
 
7662
  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
7663
    ::impl<const int&,   const field_component<T,M>&>::result_type const
 
7664
>::type
 
7665
operator/ (const int& l, const field_component<T,M>& r)
 
7666
{
 
7667
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
7668
    ::impl<const int&, const field_component<T,M>&>() (l, r);
 
7669
}
 
7670
#else // BOOST_VERSION >= 104601
 
7671
typename boost::proto::detail::enable_binary< 
 
7672
  field_domain,
 
7673
  field_domain::proto_grammar,
 
7674
  boost::mpl::and_<
 
7675
    boost::mpl::or_<is_field<int >, is_field<field_component<T,M> > >,
 
7676
    boost::mpl::not_<
 
7677
      boost::mpl::or_<
 
7678
        boost::proto::is_extension<int >,
 
7679
        boost::proto::is_extension<field_component<T,M> >
 
7680
      >
 
7681
    >
 
7682
  >,
 
7683
  boost::proto::tag::divides,
 
7684
  int const &,
 
7685
  field_component<T,M> const &
 
7686
>::type /* const */
 
7687
operator/ (int const &left, field_component<T,M> const &right)
 
7688
{
 
7689
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, int const &, field_component<T,M> const &>()(left, right);
 
7690
}
 
7691
#endif // BOOST_VERSION
 
7692
template<class T, class M>
 
7693
#if BOOST_VERSION < 104601
 
7694
typename
 
7695
boost::proto::detail::enable_binary<
 
7696
  field_domain,
 
7697
  is_field<T >,
 
7698
  T,
 
7699
  is_field<field_component<T,M> >,
 
7700
  field_component<T,M>,
 
7701
  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
7702
    ::impl<const T&,   const field_component<T,M>&>::result_type const
 
7703
>::type
 
7704
operator/ (const T& l, const field_component<T,M>& r)
 
7705
{
 
7706
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
7707
    ::impl<const T&, const field_component<T,M>&>() (l, r);
 
7708
}
 
7709
#else // BOOST_VERSION >= 104601
 
7710
typename boost::proto::detail::enable_binary< 
 
7711
  field_domain,
 
7712
  field_domain::proto_grammar,
 
7713
  boost::mpl::and_<
 
7714
    boost::mpl::or_<is_field<T >, is_field<field_component<T,M> > >,
 
7715
    boost::mpl::not_<
 
7716
      boost::mpl::or_<
 
7717
        boost::proto::is_extension<T >,
 
7718
        boost::proto::is_extension<field_component<T,M> >
 
7719
      >
 
7720
    >
 
7721
  >,
 
7722
  boost::proto::tag::divides,
 
7723
  T const &,
 
7724
  field_component<T,M> const &
 
7725
>::type /* const */
 
7726
operator/ (T const &left, field_component<T,M> const &right)
 
7727
{
 
7728
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, T const &, field_component<T,M> const &>()(left, right);
 
7729
}
 
7730
#endif // BOOST_VERSION
 
7731
template<class T, class M>
 
7732
#if BOOST_VERSION < 104601
 
7733
typename
 
7734
boost::proto::detail::enable_binary<
 
7735
  field_domain,
 
7736
  is_field<int >,
 
7737
  int,
 
7738
  is_field<field_component_const<T,M> >,
 
7739
  field_component_const<T,M>,
 
7740
  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
7741
    ::impl<const int&,   const field_component_const<T,M>&>::result_type const
 
7742
>::type
 
7743
operator/ (const int& l, const field_component_const<T,M>& r)
 
7744
{
 
7745
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
7746
    ::impl<const int&, const field_component_const<T,M>&>() (l, r);
 
7747
}
 
7748
#else // BOOST_VERSION >= 104601
 
7749
typename boost::proto::detail::enable_binary< 
 
7750
  field_domain,
 
7751
  field_domain::proto_grammar,
 
7752
  boost::mpl::and_<
 
7753
    boost::mpl::or_<is_field<int >, is_field<field_component_const<T,M> > >,
 
7754
    boost::mpl::not_<
 
7755
      boost::mpl::or_<
 
7756
        boost::proto::is_extension<int >,
 
7757
        boost::proto::is_extension<field_component_const<T,M> >
 
7758
      >
 
7759
    >
 
7760
  >,
 
7761
  boost::proto::tag::divides,
 
7762
  int const &,
 
7763
  field_component_const<T,M> const &
 
7764
>::type /* const */
 
7765
operator/ (int const &left, field_component_const<T,M> const &right)
 
7766
{
 
7767
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, int const &, field_component_const<T,M> const &>()(left, right);
 
7768
}
 
7769
#endif // BOOST_VERSION
 
7770
template<class T, class M>
 
7771
#if BOOST_VERSION < 104601
 
7772
typename
 
7773
boost::proto::detail::enable_binary<
 
7774
  field_domain,
 
7775
  is_field<T >,
 
7776
  T,
 
7777
  is_field<field_component_const<T,M> >,
 
7778
  field_component_const<T,M>,
 
7779
  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
7780
    ::impl<const T&,   const field_component_const<T,M>&>::result_type const
 
7781
>::type
 
7782
operator/ (const T& l, const field_component_const<T,M>& r)
 
7783
{
 
7784
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
7785
    ::impl<const T&, const field_component_const<T,M>&>() (l, r);
 
7786
}
 
7787
#else // BOOST_VERSION >= 104601
 
7788
typename boost::proto::detail::enable_binary< 
 
7789
  field_domain,
 
7790
  field_domain::proto_grammar,
 
7791
  boost::mpl::and_<
 
7792
    boost::mpl::or_<is_field<T >, is_field<field_component_const<T,M> > >,
 
7793
    boost::mpl::not_<
 
7794
      boost::mpl::or_<
 
7795
        boost::proto::is_extension<T >,
 
7796
        boost::proto::is_extension<field_component_const<T,M> >
 
7797
      >
 
7798
    >
 
7799
  >,
 
7800
  boost::proto::tag::divides,
 
7801
  T const &,
 
7802
  field_component_const<T,M> const &
 
7803
>::type /* const */
 
7804
operator/ (T const &left, field_component_const<T,M> const &right)
 
7805
{
 
7806
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, T const &, field_component_const<T,M> const &>()(left, right);
 
7807
}
 
7808
#endif // BOOST_VERSION
 
7809
template<class T, class M>
 
7810
#if BOOST_VERSION < 104601
1775
7811
typename
1776
7812
boost::proto::detail::enable_binary<
1777
7813
  field_domain,
1785
7821
operator/ (const field_basic<T,M>& l, const int& r)
1786
7822
{
1787
7823
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
1788
 
    ::impl<const field_basic<T,M>&,   const int&>() (l, r);
1789
 
}
 
7824
    ::impl<const field_basic<T,M>&, const int&>() (l, r);
 
7825
}
 
7826
#else // BOOST_VERSION >= 104601
 
7827
typename boost::proto::detail::enable_binary< 
 
7828
  field_domain,
 
7829
  field_domain::proto_grammar,
 
7830
  boost::mpl::and_<
 
7831
    boost::mpl::or_<is_field<field_basic<T,M> >, is_field<int > >,
 
7832
    boost::mpl::not_<
 
7833
      boost::mpl::or_<
 
7834
        boost::proto::is_extension<field_basic<T,M> >,
 
7835
        boost::proto::is_extension<int >
 
7836
      >
 
7837
    >
 
7838
  >,
 
7839
  boost::proto::tag::divides,
 
7840
  field_basic<T,M> const &,
 
7841
  int const &
 
7842
>::type /* const */
 
7843
operator/ (field_basic<T,M> const &left, int const &right)
 
7844
{
 
7845
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_basic<T,M> const &, int const &>()(left, right);
 
7846
}
 
7847
#endif // BOOST_VERSION
1790
7848
template<class T, class M>
 
7849
#if BOOST_VERSION < 104601
1791
7850
typename
1792
7851
boost::proto::detail::enable_binary<
1793
7852
  field_domain,
1801
7860
operator/ (const field_basic<T,M>& l, const T& r)
1802
7861
{
1803
7862
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
1804
 
    ::impl<const field_basic<T,M>&,   const T&>() (l, r);
1805
 
}
 
7863
    ::impl<const field_basic<T,M>&, const T&>() (l, r);
 
7864
}
 
7865
#else // BOOST_VERSION >= 104601
 
7866
typename boost::proto::detail::enable_binary< 
 
7867
  field_domain,
 
7868
  field_domain::proto_grammar,
 
7869
  boost::mpl::and_<
 
7870
    boost::mpl::or_<is_field<field_basic<T,M> >, is_field<T > >,
 
7871
    boost::mpl::not_<
 
7872
      boost::mpl::or_<
 
7873
        boost::proto::is_extension<field_basic<T,M> >,
 
7874
        boost::proto::is_extension<T >
 
7875
      >
 
7876
    >
 
7877
  >,
 
7878
  boost::proto::tag::divides,
 
7879
  field_basic<T,M> const &,
 
7880
  T const &
 
7881
>::type /* const */
 
7882
operator/ (field_basic<T,M> const &left, T const &right)
 
7883
{
 
7884
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_basic<T,M> const &, T const &>()(left, right);
 
7885
}
 
7886
#endif // BOOST_VERSION
1806
7887
template<class T, class M>
 
7888
#if BOOST_VERSION < 104601
1807
7889
typename
1808
7890
boost::proto::detail::enable_binary<
1809
7891
  field_domain,
1817
7899
operator/ (const field_indirect<T,M>& l, const int& r)
1818
7900
{
1819
7901
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
1820
 
    ::impl<const field_indirect<T,M>&,   const int&>() (l, r);
1821
 
}
 
7902
    ::impl<const field_indirect<T,M>&, const int&>() (l, r);
 
7903
}
 
7904
#else // BOOST_VERSION >= 104601
 
7905
typename boost::proto::detail::enable_binary< 
 
7906
  field_domain,
 
7907
  field_domain::proto_grammar,
 
7908
  boost::mpl::and_<
 
7909
    boost::mpl::or_<is_field<field_indirect<T,M> >, is_field<int > >,
 
7910
    boost::mpl::not_<
 
7911
      boost::mpl::or_<
 
7912
        boost::proto::is_extension<field_indirect<T,M> >,
 
7913
        boost::proto::is_extension<int >
 
7914
      >
 
7915
    >
 
7916
  >,
 
7917
  boost::proto::tag::divides,
 
7918
  field_indirect<T,M> const &,
 
7919
  int const &
 
7920
>::type /* const */
 
7921
operator/ (field_indirect<T,M> const &left, int const &right)
 
7922
{
 
7923
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_indirect<T,M> const &, int const &>()(left, right);
 
7924
}
 
7925
#endif // BOOST_VERSION
1822
7926
template<class T, class M>
 
7927
#if BOOST_VERSION < 104601
1823
7928
typename
1824
7929
boost::proto::detail::enable_binary<
1825
7930
  field_domain,
1833
7938
operator/ (const field_indirect<T,M>& l, const T& r)
1834
7939
{
1835
7940
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
1836
 
    ::impl<const field_indirect<T,M>&,   const T&>() (l, r);
1837
 
}
 
7941
    ::impl<const field_indirect<T,M>&, const T&>() (l, r);
 
7942
}
 
7943
#else // BOOST_VERSION >= 104601
 
7944
typename boost::proto::detail::enable_binary< 
 
7945
  field_domain,
 
7946
  field_domain::proto_grammar,
 
7947
  boost::mpl::and_<
 
7948
    boost::mpl::or_<is_field<field_indirect<T,M> >, is_field<T > >,
 
7949
    boost::mpl::not_<
 
7950
      boost::mpl::or_<
 
7951
        boost::proto::is_extension<field_indirect<T,M> >,
 
7952
        boost::proto::is_extension<T >
 
7953
      >
 
7954
    >
 
7955
  >,
 
7956
  boost::proto::tag::divides,
 
7957
  field_indirect<T,M> const &,
 
7958
  T const &
 
7959
>::type /* const */
 
7960
operator/ (field_indirect<T,M> const &left, T const &right)
 
7961
{
 
7962
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_indirect<T,M> const &, T const &>()(left, right);
 
7963
}
 
7964
#endif // BOOST_VERSION
1838
7965
template<class T, class M>
 
7966
#if BOOST_VERSION < 104601
1839
7967
typename
1840
7968
boost::proto::detail::enable_binary<
1841
7969
  field_domain,
1849
7977
operator/ (const field_indirect_const<T,M>& l, const int& r)
1850
7978
{
1851
7979
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
1852
 
    ::impl<const field_indirect_const<T,M>&,   const int&>() (l, r);
1853
 
}
 
7980
    ::impl<const field_indirect_const<T,M>&, const int&>() (l, r);
 
7981
}
 
7982
#else // BOOST_VERSION >= 104601
 
7983
typename boost::proto::detail::enable_binary< 
 
7984
  field_domain,
 
7985
  field_domain::proto_grammar,
 
7986
  boost::mpl::and_<
 
7987
    boost::mpl::or_<is_field<field_indirect_const<T,M> >, is_field<int > >,
 
7988
    boost::mpl::not_<
 
7989
      boost::mpl::or_<
 
7990
        boost::proto::is_extension<field_indirect_const<T,M> >,
 
7991
        boost::proto::is_extension<int >
 
7992
      >
 
7993
    >
 
7994
  >,
 
7995
  boost::proto::tag::divides,
 
7996
  field_indirect_const<T,M> const &,
 
7997
  int const &
 
7998
>::type /* const */
 
7999
operator/ (field_indirect_const<T,M> const &left, int const &right)
 
8000
{
 
8001
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_indirect_const<T,M> const &, int const &>()(left, right);
 
8002
}
 
8003
#endif // BOOST_VERSION
1854
8004
template<class T, class M>
 
8005
#if BOOST_VERSION < 104601
1855
8006
typename
1856
8007
boost::proto::detail::enable_binary<
1857
8008
  field_domain,
1865
8016
operator/ (const field_indirect_const<T,M>& l, const T& r)
1866
8017
{
1867
8018
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
1868
 
    ::impl<const field_indirect_const<T,M>&,   const T&>() (l, r);
1869
 
}
 
8019
    ::impl<const field_indirect_const<T,M>&, const T&>() (l, r);
 
8020
}
 
8021
#else // BOOST_VERSION >= 104601
 
8022
typename boost::proto::detail::enable_binary< 
 
8023
  field_domain,
 
8024
  field_domain::proto_grammar,
 
8025
  boost::mpl::and_<
 
8026
    boost::mpl::or_<is_field<field_indirect_const<T,M> >, is_field<T > >,
 
8027
    boost::mpl::not_<
 
8028
      boost::mpl::or_<
 
8029
        boost::proto::is_extension<field_indirect_const<T,M> >,
 
8030
        boost::proto::is_extension<T >
 
8031
      >
 
8032
    >
 
8033
  >,
 
8034
  boost::proto::tag::divides,
 
8035
  field_indirect_const<T,M> const &,
 
8036
  T const &
 
8037
>::type /* const */
 
8038
operator/ (field_indirect_const<T,M> const &left, T const &right)
 
8039
{
 
8040
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_indirect_const<T,M> const &, T const &>()(left, right);
 
8041
}
 
8042
#endif // BOOST_VERSION
 
8043
template<class T, class M>
 
8044
#if BOOST_VERSION < 104601
 
8045
typename
 
8046
boost::proto::detail::enable_binary<
 
8047
  field_domain,
 
8048
  is_field<field_component<T,M> >,
 
8049
  field_component<T,M>,
 
8050
  is_field<int >,
 
8051
  int,
 
8052
  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8053
    ::impl<const field_component<T,M>&,   const int&>::result_type const
 
8054
>::type
 
8055
operator/ (const field_component<T,M>& l, const int& r)
 
8056
{
 
8057
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8058
    ::impl<const field_component<T,M>&, const int&>() (l, r);
 
8059
}
 
8060
#else // BOOST_VERSION >= 104601
 
8061
typename boost::proto::detail::enable_binary< 
 
8062
  field_domain,
 
8063
  field_domain::proto_grammar,
 
8064
  boost::mpl::and_<
 
8065
    boost::mpl::or_<is_field<field_component<T,M> >, is_field<int > >,
 
8066
    boost::mpl::not_<
 
8067
      boost::mpl::or_<
 
8068
        boost::proto::is_extension<field_component<T,M> >,
 
8069
        boost::proto::is_extension<int >
 
8070
      >
 
8071
    >
 
8072
  >,
 
8073
  boost::proto::tag::divides,
 
8074
  field_component<T,M> const &,
 
8075
  int const &
 
8076
>::type /* const */
 
8077
operator/ (field_component<T,M> const &left, int const &right)
 
8078
{
 
8079
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_component<T,M> const &, int const &>()(left, right);
 
8080
}
 
8081
#endif // BOOST_VERSION
 
8082
template<class T, class M>
 
8083
#if BOOST_VERSION < 104601
 
8084
typename
 
8085
boost::proto::detail::enable_binary<
 
8086
  field_domain,
 
8087
  is_field<field_component<T,M> >,
 
8088
  field_component<T,M>,
 
8089
  is_field<T >,
 
8090
  T,
 
8091
  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8092
    ::impl<const field_component<T,M>&,   const T&>::result_type const
 
8093
>::type
 
8094
operator/ (const field_component<T,M>& l, const T& r)
 
8095
{
 
8096
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8097
    ::impl<const field_component<T,M>&, const T&>() (l, r);
 
8098
}
 
8099
#else // BOOST_VERSION >= 104601
 
8100
typename boost::proto::detail::enable_binary< 
 
8101
  field_domain,
 
8102
  field_domain::proto_grammar,
 
8103
  boost::mpl::and_<
 
8104
    boost::mpl::or_<is_field<field_component<T,M> >, is_field<T > >,
 
8105
    boost::mpl::not_<
 
8106
      boost::mpl::or_<
 
8107
        boost::proto::is_extension<field_component<T,M> >,
 
8108
        boost::proto::is_extension<T >
 
8109
      >
 
8110
    >
 
8111
  >,
 
8112
  boost::proto::tag::divides,
 
8113
  field_component<T,M> const &,
 
8114
  T const &
 
8115
>::type /* const */
 
8116
operator/ (field_component<T,M> const &left, T const &right)
 
8117
{
 
8118
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_component<T,M> const &, T const &>()(left, right);
 
8119
}
 
8120
#endif // BOOST_VERSION
 
8121
template<class T, class M>
 
8122
#if BOOST_VERSION < 104601
 
8123
typename
 
8124
boost::proto::detail::enable_binary<
 
8125
  field_domain,
 
8126
  is_field<field_component_const<T,M> >,
 
8127
  field_component_const<T,M>,
 
8128
  is_field<int >,
 
8129
  int,
 
8130
  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8131
    ::impl<const field_component_const<T,M>&,   const int&>::result_type const
 
8132
>::type
 
8133
operator/ (const field_component_const<T,M>& l, const int& r)
 
8134
{
 
8135
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8136
    ::impl<const field_component_const<T,M>&, const int&>() (l, r);
 
8137
}
 
8138
#else // BOOST_VERSION >= 104601
 
8139
typename boost::proto::detail::enable_binary< 
 
8140
  field_domain,
 
8141
  field_domain::proto_grammar,
 
8142
  boost::mpl::and_<
 
8143
    boost::mpl::or_<is_field<field_component_const<T,M> >, is_field<int > >,
 
8144
    boost::mpl::not_<
 
8145
      boost::mpl::or_<
 
8146
        boost::proto::is_extension<field_component_const<T,M> >,
 
8147
        boost::proto::is_extension<int >
 
8148
      >
 
8149
    >
 
8150
  >,
 
8151
  boost::proto::tag::divides,
 
8152
  field_component_const<T,M> const &,
 
8153
  int const &
 
8154
>::type /* const */
 
8155
operator/ (field_component_const<T,M> const &left, int const &right)
 
8156
{
 
8157
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_component_const<T,M> const &, int const &>()(left, right);
 
8158
}
 
8159
#endif // BOOST_VERSION
 
8160
template<class T, class M>
 
8161
#if BOOST_VERSION < 104601
 
8162
typename
 
8163
boost::proto::detail::enable_binary<
 
8164
  field_domain,
 
8165
  is_field<field_component_const<T,M> >,
 
8166
  field_component_const<T,M>,
 
8167
  is_field<T >,
 
8168
  T,
 
8169
  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8170
    ::impl<const field_component_const<T,M>&,   const T&>::result_type const
 
8171
>::type
 
8172
operator/ (const field_component_const<T,M>& l, const T& r)
 
8173
{
 
8174
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8175
    ::impl<const field_component_const<T,M>&, const T&>() (l, r);
 
8176
}
 
8177
#else // BOOST_VERSION >= 104601
 
8178
typename boost::proto::detail::enable_binary< 
 
8179
  field_domain,
 
8180
  field_domain::proto_grammar,
 
8181
  boost::mpl::and_<
 
8182
    boost::mpl::or_<is_field<field_component_const<T,M> >, is_field<T > >,
 
8183
    boost::mpl::not_<
 
8184
      boost::mpl::or_<
 
8185
        boost::proto::is_extension<field_component_const<T,M> >,
 
8186
        boost::proto::is_extension<T >
 
8187
      >
 
8188
    >
 
8189
  >,
 
8190
  boost::proto::tag::divides,
 
8191
  field_component_const<T,M> const &,
 
8192
  T const &
 
8193
>::type /* const */
 
8194
operator/ (field_component_const<T,M> const &left, T const &right)
 
8195
{
 
8196
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_component_const<T,M> const &, T const &>()(left, right);
 
8197
}
 
8198
#endif // BOOST_VERSION
1870
8199
template<class T1, class T2, class M>
 
8200
#if BOOST_VERSION < 104601
1871
8201
typename
1872
8202
boost::proto::detail::enable_binary<
1873
8203
  field_domain,
1881
8211
operator/ (const field_basic<T1,M>& l, const field_basic<T2,M>& r)
1882
8212
{
1883
8213
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
1884
 
    ::impl<const field_basic<T1,M>&,   const field_basic<T2,M>&>() (l, r);
1885
 
}
 
8214
    ::impl<const field_basic<T1,M>&, const field_basic<T2,M>&>() (l, r);
 
8215
}
 
8216
#else // BOOST_VERSION >= 104601
 
8217
typename boost::proto::detail::enable_binary< 
 
8218
  field_domain,
 
8219
  field_domain::proto_grammar,
 
8220
  boost::mpl::and_<
 
8221
    boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_basic<T2,M> > >,
 
8222
    boost::mpl::not_<
 
8223
      boost::mpl::or_<
 
8224
        boost::proto::is_extension<field_basic<T1,M> >,
 
8225
        boost::proto::is_extension<field_basic<T2,M> >
 
8226
      >
 
8227
    >
 
8228
  >,
 
8229
  boost::proto::tag::divides,
 
8230
  field_basic<T1,M> const &,
 
8231
  field_basic<T2,M> const &
 
8232
>::type /* const */
 
8233
operator/ (field_basic<T1,M> const &left, field_basic<T2,M> const &right)
 
8234
{
 
8235
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_basic<T1,M> const &, field_basic<T2,M> const &>()(left, right);
 
8236
}
 
8237
#endif // BOOST_VERSION
1886
8238
template<class T1, class T2, class M>
 
8239
#if BOOST_VERSION < 104601
1887
8240
typename
1888
8241
boost::proto::detail::enable_binary<
1889
8242
  field_domain,
1897
8250
operator/ (const field_basic<T1,M>& l, const field_indirect<T2,M>& r)
1898
8251
{
1899
8252
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
1900
 
    ::impl<const field_basic<T1,M>&,   const field_indirect<T2,M>&>() (l, r);
1901
 
}
 
8253
    ::impl<const field_basic<T1,M>&, const field_indirect<T2,M>&>() (l, r);
 
8254
}
 
8255
#else // BOOST_VERSION >= 104601
 
8256
typename boost::proto::detail::enable_binary< 
 
8257
  field_domain,
 
8258
  field_domain::proto_grammar,
 
8259
  boost::mpl::and_<
 
8260
    boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_indirect<T2,M> > >,
 
8261
    boost::mpl::not_<
 
8262
      boost::mpl::or_<
 
8263
        boost::proto::is_extension<field_basic<T1,M> >,
 
8264
        boost::proto::is_extension<field_indirect<T2,M> >
 
8265
      >
 
8266
    >
 
8267
  >,
 
8268
  boost::proto::tag::divides,
 
8269
  field_basic<T1,M> const &,
 
8270
  field_indirect<T2,M> const &
 
8271
>::type /* const */
 
8272
operator/ (field_basic<T1,M> const &left, field_indirect<T2,M> const &right)
 
8273
{
 
8274
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_basic<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
 
8275
}
 
8276
#endif // BOOST_VERSION
1902
8277
template<class T1, class T2, class M>
 
8278
#if BOOST_VERSION < 104601
1903
8279
typename
1904
8280
boost::proto::detail::enable_binary<
1905
8281
  field_domain,
1913
8289
operator/ (const field_basic<T1,M>& l, const field_indirect_const<T2,M>& r)
1914
8290
{
1915
8291
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
1916
 
    ::impl<const field_basic<T1,M>&,   const field_indirect_const<T2,M>&>() (l, r);
1917
 
}
1918
 
template<class T1, class T2, class M>
 
8292
    ::impl<const field_basic<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
 
8293
}
 
8294
#else // BOOST_VERSION >= 104601
 
8295
typename boost::proto::detail::enable_binary< 
 
8296
  field_domain,
 
8297
  field_domain::proto_grammar,
 
8298
  boost::mpl::and_<
 
8299
    boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_indirect_const<T2,M> > >,
 
8300
    boost::mpl::not_<
 
8301
      boost::mpl::or_<
 
8302
        boost::proto::is_extension<field_basic<T1,M> >,
 
8303
        boost::proto::is_extension<field_indirect_const<T2,M> >
 
8304
      >
 
8305
    >
 
8306
  >,
 
8307
  boost::proto::tag::divides,
 
8308
  field_basic<T1,M> const &,
 
8309
  field_indirect_const<T2,M> const &
 
8310
>::type /* const */
 
8311
operator/ (field_basic<T1,M> const &left, field_indirect_const<T2,M> const &right)
 
8312
{
 
8313
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_basic<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
 
8314
}
 
8315
#endif // BOOST_VERSION
 
8316
template<class T1, class T2, class M>
 
8317
#if BOOST_VERSION < 104601
 
8318
typename
 
8319
boost::proto::detail::enable_binary<
 
8320
  field_domain,
 
8321
  is_field<field_basic<T1,M> >,
 
8322
  field_basic<T1,M>,
 
8323
  is_field<field_component<T2,M> >,
 
8324
  field_component<T2,M>,
 
8325
  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8326
    ::impl<const field_basic<T1,M>&,   const field_component<T2,M>&>::result_type const
 
8327
>::type
 
8328
operator/ (const field_basic<T1,M>& l, const field_component<T2,M>& r)
 
8329
{
 
8330
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8331
    ::impl<const field_basic<T1,M>&, const field_component<T2,M>&>() (l, r);
 
8332
}
 
8333
#else // BOOST_VERSION >= 104601
 
8334
typename boost::proto::detail::enable_binary< 
 
8335
  field_domain,
 
8336
  field_domain::proto_grammar,
 
8337
  boost::mpl::and_<
 
8338
    boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_component<T2,M> > >,
 
8339
    boost::mpl::not_<
 
8340
      boost::mpl::or_<
 
8341
        boost::proto::is_extension<field_basic<T1,M> >,
 
8342
        boost::proto::is_extension<field_component<T2,M> >
 
8343
      >
 
8344
    >
 
8345
  >,
 
8346
  boost::proto::tag::divides,
 
8347
  field_basic<T1,M> const &,
 
8348
  field_component<T2,M> const &
 
8349
>::type /* const */
 
8350
operator/ (field_basic<T1,M> const &left, field_component<T2,M> const &right)
 
8351
{
 
8352
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_basic<T1,M> const &, field_component<T2,M> const &>()(left, right);
 
8353
}
 
8354
#endif // BOOST_VERSION
 
8355
template<class T1, class T2, class M>
 
8356
#if BOOST_VERSION < 104601
 
8357
typename
 
8358
boost::proto::detail::enable_binary<
 
8359
  field_domain,
 
8360
  is_field<field_basic<T1,M> >,
 
8361
  field_basic<T1,M>,
 
8362
  is_field<field_component_const<T2,M> >,
 
8363
  field_component_const<T2,M>,
 
8364
  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8365
    ::impl<const field_basic<T1,M>&,   const field_component_const<T2,M>&>::result_type const
 
8366
>::type
 
8367
operator/ (const field_basic<T1,M>& l, const field_component_const<T2,M>& r)
 
8368
{
 
8369
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8370
    ::impl<const field_basic<T1,M>&, const field_component_const<T2,M>&>() (l, r);
 
8371
}
 
8372
#else // BOOST_VERSION >= 104601
 
8373
typename boost::proto::detail::enable_binary< 
 
8374
  field_domain,
 
8375
  field_domain::proto_grammar,
 
8376
  boost::mpl::and_<
 
8377
    boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_component_const<T2,M> > >,
 
8378
    boost::mpl::not_<
 
8379
      boost::mpl::or_<
 
8380
        boost::proto::is_extension<field_basic<T1,M> >,
 
8381
        boost::proto::is_extension<field_component_const<T2,M> >
 
8382
      >
 
8383
    >
 
8384
  >,
 
8385
  boost::proto::tag::divides,
 
8386
  field_basic<T1,M> const &,
 
8387
  field_component_const<T2,M> const &
 
8388
>::type /* const */
 
8389
operator/ (field_basic<T1,M> const &left, field_component_const<T2,M> const &right)
 
8390
{
 
8391
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_basic<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
 
8392
}
 
8393
#endif // BOOST_VERSION
 
8394
template<class T1, class T2, class M>
 
8395
#if BOOST_VERSION < 104601
1919
8396
typename
1920
8397
boost::proto::detail::enable_binary<
1921
8398
  field_domain,
1929
8406
operator/ (const field_indirect<T1,M>& l, const field_basic<T2,M>& r)
1930
8407
{
1931
8408
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
1932
 
    ::impl<const field_indirect<T1,M>&,   const field_basic<T2,M>&>() (l, r);
1933
 
}
 
8409
    ::impl<const field_indirect<T1,M>&, const field_basic<T2,M>&>() (l, r);
 
8410
}
 
8411
#else // BOOST_VERSION >= 104601
 
8412
typename boost::proto::detail::enable_binary< 
 
8413
  field_domain,
 
8414
  field_domain::proto_grammar,
 
8415
  boost::mpl::and_<
 
8416
    boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_basic<T2,M> > >,
 
8417
    boost::mpl::not_<
 
8418
      boost::mpl::or_<
 
8419
        boost::proto::is_extension<field_indirect<T1,M> >,
 
8420
        boost::proto::is_extension<field_basic<T2,M> >
 
8421
      >
 
8422
    >
 
8423
  >,
 
8424
  boost::proto::tag::divides,
 
8425
  field_indirect<T1,M> const &,
 
8426
  field_basic<T2,M> const &
 
8427
>::type /* const */
 
8428
operator/ (field_indirect<T1,M> const &left, field_basic<T2,M> const &right)
 
8429
{
 
8430
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_indirect<T1,M> const &, field_basic<T2,M> const &>()(left, right);
 
8431
}
 
8432
#endif // BOOST_VERSION
1934
8433
template<class T1, class T2, class M>
 
8434
#if BOOST_VERSION < 104601
1935
8435
typename
1936
8436
boost::proto::detail::enable_binary<
1937
8437
  field_domain,
1945
8445
operator/ (const field_indirect<T1,M>& l, const field_indirect<T2,M>& r)
1946
8446
{
1947
8447
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
1948
 
    ::impl<const field_indirect<T1,M>&,   const field_indirect<T2,M>&>() (l, r);
1949
 
}
 
8448
    ::impl<const field_indirect<T1,M>&, const field_indirect<T2,M>&>() (l, r);
 
8449
}
 
8450
#else // BOOST_VERSION >= 104601
 
8451
typename boost::proto::detail::enable_binary< 
 
8452
  field_domain,
 
8453
  field_domain::proto_grammar,
 
8454
  boost::mpl::and_<
 
8455
    boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_indirect<T2,M> > >,
 
8456
    boost::mpl::not_<
 
8457
      boost::mpl::or_<
 
8458
        boost::proto::is_extension<field_indirect<T1,M> >,
 
8459
        boost::proto::is_extension<field_indirect<T2,M> >
 
8460
      >
 
8461
    >
 
8462
  >,
 
8463
  boost::proto::tag::divides,
 
8464
  field_indirect<T1,M> const &,
 
8465
  field_indirect<T2,M> const &
 
8466
>::type /* const */
 
8467
operator/ (field_indirect<T1,M> const &left, field_indirect<T2,M> const &right)
 
8468
{
 
8469
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_indirect<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
 
8470
}
 
8471
#endif // BOOST_VERSION
1950
8472
template<class T1, class T2, class M>
 
8473
#if BOOST_VERSION < 104601
1951
8474
typename
1952
8475
boost::proto::detail::enable_binary<
1953
8476
  field_domain,
1961
8484
operator/ (const field_indirect<T1,M>& l, const field_indirect_const<T2,M>& r)
1962
8485
{
1963
8486
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
1964
 
    ::impl<const field_indirect<T1,M>&,   const field_indirect_const<T2,M>&>() (l, r);
1965
 
}
1966
 
template<class T1, class T2, class M>
 
8487
    ::impl<const field_indirect<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
 
8488
}
 
8489
#else // BOOST_VERSION >= 104601
 
8490
typename boost::proto::detail::enable_binary< 
 
8491
  field_domain,
 
8492
  field_domain::proto_grammar,
 
8493
  boost::mpl::and_<
 
8494
    boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_indirect_const<T2,M> > >,
 
8495
    boost::mpl::not_<
 
8496
      boost::mpl::or_<
 
8497
        boost::proto::is_extension<field_indirect<T1,M> >,
 
8498
        boost::proto::is_extension<field_indirect_const<T2,M> >
 
8499
      >
 
8500
    >
 
8501
  >,
 
8502
  boost::proto::tag::divides,
 
8503
  field_indirect<T1,M> const &,
 
8504
  field_indirect_const<T2,M> const &
 
8505
>::type /* const */
 
8506
operator/ (field_indirect<T1,M> const &left, field_indirect_const<T2,M> const &right)
 
8507
{
 
8508
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_indirect<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
 
8509
}
 
8510
#endif // BOOST_VERSION
 
8511
template<class T1, class T2, class M>
 
8512
#if BOOST_VERSION < 104601
 
8513
typename
 
8514
boost::proto::detail::enable_binary<
 
8515
  field_domain,
 
8516
  is_field<field_indirect<T1,M> >,
 
8517
  field_indirect<T1,M>,
 
8518
  is_field<field_component<T2,M> >,
 
8519
  field_component<T2,M>,
 
8520
  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8521
    ::impl<const field_indirect<T1,M>&,   const field_component<T2,M>&>::result_type const
 
8522
>::type
 
8523
operator/ (const field_indirect<T1,M>& l, const field_component<T2,M>& r)
 
8524
{
 
8525
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8526
    ::impl<const field_indirect<T1,M>&, const field_component<T2,M>&>() (l, r);
 
8527
}
 
8528
#else // BOOST_VERSION >= 104601
 
8529
typename boost::proto::detail::enable_binary< 
 
8530
  field_domain,
 
8531
  field_domain::proto_grammar,
 
8532
  boost::mpl::and_<
 
8533
    boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_component<T2,M> > >,
 
8534
    boost::mpl::not_<
 
8535
      boost::mpl::or_<
 
8536
        boost::proto::is_extension<field_indirect<T1,M> >,
 
8537
        boost::proto::is_extension<field_component<T2,M> >
 
8538
      >
 
8539
    >
 
8540
  >,
 
8541
  boost::proto::tag::divides,
 
8542
  field_indirect<T1,M> const &,
 
8543
  field_component<T2,M> const &
 
8544
>::type /* const */
 
8545
operator/ (field_indirect<T1,M> const &left, field_component<T2,M> const &right)
 
8546
{
 
8547
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_indirect<T1,M> const &, field_component<T2,M> const &>()(left, right);
 
8548
}
 
8549
#endif // BOOST_VERSION
 
8550
template<class T1, class T2, class M>
 
8551
#if BOOST_VERSION < 104601
 
8552
typename
 
8553
boost::proto::detail::enable_binary<
 
8554
  field_domain,
 
8555
  is_field<field_indirect<T1,M> >,
 
8556
  field_indirect<T1,M>,
 
8557
  is_field<field_component_const<T2,M> >,
 
8558
  field_component_const<T2,M>,
 
8559
  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8560
    ::impl<const field_indirect<T1,M>&,   const field_component_const<T2,M>&>::result_type const
 
8561
>::type
 
8562
operator/ (const field_indirect<T1,M>& l, const field_component_const<T2,M>& r)
 
8563
{
 
8564
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8565
    ::impl<const field_indirect<T1,M>&, const field_component_const<T2,M>&>() (l, r);
 
8566
}
 
8567
#else // BOOST_VERSION >= 104601
 
8568
typename boost::proto::detail::enable_binary< 
 
8569
  field_domain,
 
8570
  field_domain::proto_grammar,
 
8571
  boost::mpl::and_<
 
8572
    boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_component_const<T2,M> > >,
 
8573
    boost::mpl::not_<
 
8574
      boost::mpl::or_<
 
8575
        boost::proto::is_extension<field_indirect<T1,M> >,
 
8576
        boost::proto::is_extension<field_component_const<T2,M> >
 
8577
      >
 
8578
    >
 
8579
  >,
 
8580
  boost::proto::tag::divides,
 
8581
  field_indirect<T1,M> const &,
 
8582
  field_component_const<T2,M> const &
 
8583
>::type /* const */
 
8584
operator/ (field_indirect<T1,M> const &left, field_component_const<T2,M> const &right)
 
8585
{
 
8586
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_indirect<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
 
8587
}
 
8588
#endif // BOOST_VERSION
 
8589
template<class T1, class T2, class M>
 
8590
#if BOOST_VERSION < 104601
1967
8591
typename
1968
8592
boost::proto::detail::enable_binary<
1969
8593
  field_domain,
1977
8601
operator/ (const field_indirect_const<T1,M>& l, const field_basic<T2,M>& r)
1978
8602
{
1979
8603
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
1980
 
    ::impl<const field_indirect_const<T1,M>&,   const field_basic<T2,M>&>() (l, r);
1981
 
}
 
8604
    ::impl<const field_indirect_const<T1,M>&, const field_basic<T2,M>&>() (l, r);
 
8605
}
 
8606
#else // BOOST_VERSION >= 104601
 
8607
typename boost::proto::detail::enable_binary< 
 
8608
  field_domain,
 
8609
  field_domain::proto_grammar,
 
8610
  boost::mpl::and_<
 
8611
    boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_basic<T2,M> > >,
 
8612
    boost::mpl::not_<
 
8613
      boost::mpl::or_<
 
8614
        boost::proto::is_extension<field_indirect_const<T1,M> >,
 
8615
        boost::proto::is_extension<field_basic<T2,M> >
 
8616
      >
 
8617
    >
 
8618
  >,
 
8619
  boost::proto::tag::divides,
 
8620
  field_indirect_const<T1,M> const &,
 
8621
  field_basic<T2,M> const &
 
8622
>::type /* const */
 
8623
operator/ (field_indirect_const<T1,M> const &left, field_basic<T2,M> const &right)
 
8624
{
 
8625
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_indirect_const<T1,M> const &, field_basic<T2,M> const &>()(left, right);
 
8626
}
 
8627
#endif // BOOST_VERSION
1982
8628
template<class T1, class T2, class M>
 
8629
#if BOOST_VERSION < 104601
1983
8630
typename
1984
8631
boost::proto::detail::enable_binary<
1985
8632
  field_domain,
1993
8640
operator/ (const field_indirect_const<T1,M>& l, const field_indirect<T2,M>& r)
1994
8641
{
1995
8642
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
1996
 
    ::impl<const field_indirect_const<T1,M>&,   const field_indirect<T2,M>&>() (l, r);
1997
 
}
 
8643
    ::impl<const field_indirect_const<T1,M>&, const field_indirect<T2,M>&>() (l, r);
 
8644
}
 
8645
#else // BOOST_VERSION >= 104601
 
8646
typename boost::proto::detail::enable_binary< 
 
8647
  field_domain,
 
8648
  field_domain::proto_grammar,
 
8649
  boost::mpl::and_<
 
8650
    boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_indirect<T2,M> > >,
 
8651
    boost::mpl::not_<
 
8652
      boost::mpl::or_<
 
8653
        boost::proto::is_extension<field_indirect_const<T1,M> >,
 
8654
        boost::proto::is_extension<field_indirect<T2,M> >
 
8655
      >
 
8656
    >
 
8657
  >,
 
8658
  boost::proto::tag::divides,
 
8659
  field_indirect_const<T1,M> const &,
 
8660
  field_indirect<T2,M> const &
 
8661
>::type /* const */
 
8662
operator/ (field_indirect_const<T1,M> const &left, field_indirect<T2,M> const &right)
 
8663
{
 
8664
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_indirect_const<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
 
8665
}
 
8666
#endif // BOOST_VERSION
1998
8667
template<class T1, class T2, class M>
 
8668
#if BOOST_VERSION < 104601
1999
8669
typename
2000
8670
boost::proto::detail::enable_binary<
2001
8671
  field_domain,
2009
8679
operator/ (const field_indirect_const<T1,M>& l, const field_indirect_const<T2,M>& r)
2010
8680
{
2011
8681
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
2012
 
    ::impl<const field_indirect_const<T1,M>&,   const field_indirect_const<T2,M>&>() (l, r);
2013
 
}
 
8682
    ::impl<const field_indirect_const<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
 
8683
}
 
8684
#else // BOOST_VERSION >= 104601
 
8685
typename boost::proto::detail::enable_binary< 
 
8686
  field_domain,
 
8687
  field_domain::proto_grammar,
 
8688
  boost::mpl::and_<
 
8689
    boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_indirect_const<T2,M> > >,
 
8690
    boost::mpl::not_<
 
8691
      boost::mpl::or_<
 
8692
        boost::proto::is_extension<field_indirect_const<T1,M> >,
 
8693
        boost::proto::is_extension<field_indirect_const<T2,M> >
 
8694
      >
 
8695
    >
 
8696
  >,
 
8697
  boost::proto::tag::divides,
 
8698
  field_indirect_const<T1,M> const &,
 
8699
  field_indirect_const<T2,M> const &
 
8700
>::type /* const */
 
8701
operator/ (field_indirect_const<T1,M> const &left, field_indirect_const<T2,M> const &right)
 
8702
{
 
8703
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_indirect_const<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
 
8704
}
 
8705
#endif // BOOST_VERSION
 
8706
template<class T1, class T2, class M>
 
8707
#if BOOST_VERSION < 104601
 
8708
typename
 
8709
boost::proto::detail::enable_binary<
 
8710
  field_domain,
 
8711
  is_field<field_indirect_const<T1,M> >,
 
8712
  field_indirect_const<T1,M>,
 
8713
  is_field<field_component<T2,M> >,
 
8714
  field_component<T2,M>,
 
8715
  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8716
    ::impl<const field_indirect_const<T1,M>&,   const field_component<T2,M>&>::result_type const
 
8717
>::type
 
8718
operator/ (const field_indirect_const<T1,M>& l, const field_component<T2,M>& r)
 
8719
{
 
8720
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8721
    ::impl<const field_indirect_const<T1,M>&, const field_component<T2,M>&>() (l, r);
 
8722
}
 
8723
#else // BOOST_VERSION >= 104601
 
8724
typename boost::proto::detail::enable_binary< 
 
8725
  field_domain,
 
8726
  field_domain::proto_grammar,
 
8727
  boost::mpl::and_<
 
8728
    boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_component<T2,M> > >,
 
8729
    boost::mpl::not_<
 
8730
      boost::mpl::or_<
 
8731
        boost::proto::is_extension<field_indirect_const<T1,M> >,
 
8732
        boost::proto::is_extension<field_component<T2,M> >
 
8733
      >
 
8734
    >
 
8735
  >,
 
8736
  boost::proto::tag::divides,
 
8737
  field_indirect_const<T1,M> const &,
 
8738
  field_component<T2,M> const &
 
8739
>::type /* const */
 
8740
operator/ (field_indirect_const<T1,M> const &left, field_component<T2,M> const &right)
 
8741
{
 
8742
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_indirect_const<T1,M> const &, field_component<T2,M> const &>()(left, right);
 
8743
}
 
8744
#endif // BOOST_VERSION
 
8745
template<class T1, class T2, class M>
 
8746
#if BOOST_VERSION < 104601
 
8747
typename
 
8748
boost::proto::detail::enable_binary<
 
8749
  field_domain,
 
8750
  is_field<field_indirect_const<T1,M> >,
 
8751
  field_indirect_const<T1,M>,
 
8752
  is_field<field_component_const<T2,M> >,
 
8753
  field_component_const<T2,M>,
 
8754
  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8755
    ::impl<const field_indirect_const<T1,M>&,   const field_component_const<T2,M>&>::result_type const
 
8756
>::type
 
8757
operator/ (const field_indirect_const<T1,M>& l, const field_component_const<T2,M>& r)
 
8758
{
 
8759
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8760
    ::impl<const field_indirect_const<T1,M>&, const field_component_const<T2,M>&>() (l, r);
 
8761
}
 
8762
#else // BOOST_VERSION >= 104601
 
8763
typename boost::proto::detail::enable_binary< 
 
8764
  field_domain,
 
8765
  field_domain::proto_grammar,
 
8766
  boost::mpl::and_<
 
8767
    boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_component_const<T2,M> > >,
 
8768
    boost::mpl::not_<
 
8769
      boost::mpl::or_<
 
8770
        boost::proto::is_extension<field_indirect_const<T1,M> >,
 
8771
        boost::proto::is_extension<field_component_const<T2,M> >
 
8772
      >
 
8773
    >
 
8774
  >,
 
8775
  boost::proto::tag::divides,
 
8776
  field_indirect_const<T1,M> const &,
 
8777
  field_component_const<T2,M> const &
 
8778
>::type /* const */
 
8779
operator/ (field_indirect_const<T1,M> const &left, field_component_const<T2,M> const &right)
 
8780
{
 
8781
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_indirect_const<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
 
8782
}
 
8783
#endif // BOOST_VERSION
 
8784
template<class T1, class T2, class M>
 
8785
#if BOOST_VERSION < 104601
 
8786
typename
 
8787
boost::proto::detail::enable_binary<
 
8788
  field_domain,
 
8789
  is_field<field_component<T1,M> >,
 
8790
  field_component<T1,M>,
 
8791
  is_field<field_basic<T2,M> >,
 
8792
  field_basic<T2,M>,
 
8793
  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8794
    ::impl<const field_component<T1,M>&,   const field_basic<T2,M>&>::result_type const
 
8795
>::type
 
8796
operator/ (const field_component<T1,M>& l, const field_basic<T2,M>& r)
 
8797
{
 
8798
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8799
    ::impl<const field_component<T1,M>&, const field_basic<T2,M>&>() (l, r);
 
8800
}
 
8801
#else // BOOST_VERSION >= 104601
 
8802
typename boost::proto::detail::enable_binary< 
 
8803
  field_domain,
 
8804
  field_domain::proto_grammar,
 
8805
  boost::mpl::and_<
 
8806
    boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_basic<T2,M> > >,
 
8807
    boost::mpl::not_<
 
8808
      boost::mpl::or_<
 
8809
        boost::proto::is_extension<field_component<T1,M> >,
 
8810
        boost::proto::is_extension<field_basic<T2,M> >
 
8811
      >
 
8812
    >
 
8813
  >,
 
8814
  boost::proto::tag::divides,
 
8815
  field_component<T1,M> const &,
 
8816
  field_basic<T2,M> const &
 
8817
>::type /* const */
 
8818
operator/ (field_component<T1,M> const &left, field_basic<T2,M> const &right)
 
8819
{
 
8820
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_component<T1,M> const &, field_basic<T2,M> const &>()(left, right);
 
8821
}
 
8822
#endif // BOOST_VERSION
 
8823
template<class T1, class T2, class M>
 
8824
#if BOOST_VERSION < 104601
 
8825
typename
 
8826
boost::proto::detail::enable_binary<
 
8827
  field_domain,
 
8828
  is_field<field_component<T1,M> >,
 
8829
  field_component<T1,M>,
 
8830
  is_field<field_indirect<T2,M> >,
 
8831
  field_indirect<T2,M>,
 
8832
  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8833
    ::impl<const field_component<T1,M>&,   const field_indirect<T2,M>&>::result_type const
 
8834
>::type
 
8835
operator/ (const field_component<T1,M>& l, const field_indirect<T2,M>& r)
 
8836
{
 
8837
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8838
    ::impl<const field_component<T1,M>&, const field_indirect<T2,M>&>() (l, r);
 
8839
}
 
8840
#else // BOOST_VERSION >= 104601
 
8841
typename boost::proto::detail::enable_binary< 
 
8842
  field_domain,
 
8843
  field_domain::proto_grammar,
 
8844
  boost::mpl::and_<
 
8845
    boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_indirect<T2,M> > >,
 
8846
    boost::mpl::not_<
 
8847
      boost::mpl::or_<
 
8848
        boost::proto::is_extension<field_component<T1,M> >,
 
8849
        boost::proto::is_extension<field_indirect<T2,M> >
 
8850
      >
 
8851
    >
 
8852
  >,
 
8853
  boost::proto::tag::divides,
 
8854
  field_component<T1,M> const &,
 
8855
  field_indirect<T2,M> const &
 
8856
>::type /* const */
 
8857
operator/ (field_component<T1,M> const &left, field_indirect<T2,M> const &right)
 
8858
{
 
8859
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_component<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
 
8860
}
 
8861
#endif // BOOST_VERSION
 
8862
template<class T1, class T2, class M>
 
8863
#if BOOST_VERSION < 104601
 
8864
typename
 
8865
boost::proto::detail::enable_binary<
 
8866
  field_domain,
 
8867
  is_field<field_component<T1,M> >,
 
8868
  field_component<T1,M>,
 
8869
  is_field<field_indirect_const<T2,M> >,
 
8870
  field_indirect_const<T2,M>,
 
8871
  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8872
    ::impl<const field_component<T1,M>&,   const field_indirect_const<T2,M>&>::result_type const
 
8873
>::type
 
8874
operator/ (const field_component<T1,M>& l, const field_indirect_const<T2,M>& r)
 
8875
{
 
8876
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8877
    ::impl<const field_component<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
 
8878
}
 
8879
#else // BOOST_VERSION >= 104601
 
8880
typename boost::proto::detail::enable_binary< 
 
8881
  field_domain,
 
8882
  field_domain::proto_grammar,
 
8883
  boost::mpl::and_<
 
8884
    boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_indirect_const<T2,M> > >,
 
8885
    boost::mpl::not_<
 
8886
      boost::mpl::or_<
 
8887
        boost::proto::is_extension<field_component<T1,M> >,
 
8888
        boost::proto::is_extension<field_indirect_const<T2,M> >
 
8889
      >
 
8890
    >
 
8891
  >,
 
8892
  boost::proto::tag::divides,
 
8893
  field_component<T1,M> const &,
 
8894
  field_indirect_const<T2,M> const &
 
8895
>::type /* const */
 
8896
operator/ (field_component<T1,M> const &left, field_indirect_const<T2,M> const &right)
 
8897
{
 
8898
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_component<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
 
8899
}
 
8900
#endif // BOOST_VERSION
 
8901
template<class T1, class T2, class M>
 
8902
#if BOOST_VERSION < 104601
 
8903
typename
 
8904
boost::proto::detail::enable_binary<
 
8905
  field_domain,
 
8906
  is_field<field_component<T1,M> >,
 
8907
  field_component<T1,M>,
 
8908
  is_field<field_component<T2,M> >,
 
8909
  field_component<T2,M>,
 
8910
  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8911
    ::impl<const field_component<T1,M>&,   const field_component<T2,M>&>::result_type const
 
8912
>::type
 
8913
operator/ (const field_component<T1,M>& l, const field_component<T2,M>& r)
 
8914
{
 
8915
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8916
    ::impl<const field_component<T1,M>&, const field_component<T2,M>&>() (l, r);
 
8917
}
 
8918
#else // BOOST_VERSION >= 104601
 
8919
typename boost::proto::detail::enable_binary< 
 
8920
  field_domain,
 
8921
  field_domain::proto_grammar,
 
8922
  boost::mpl::and_<
 
8923
    boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_component<T2,M> > >,
 
8924
    boost::mpl::not_<
 
8925
      boost::mpl::or_<
 
8926
        boost::proto::is_extension<field_component<T1,M> >,
 
8927
        boost::proto::is_extension<field_component<T2,M> >
 
8928
      >
 
8929
    >
 
8930
  >,
 
8931
  boost::proto::tag::divides,
 
8932
  field_component<T1,M> const &,
 
8933
  field_component<T2,M> const &
 
8934
>::type /* const */
 
8935
operator/ (field_component<T1,M> const &left, field_component<T2,M> const &right)
 
8936
{
 
8937
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_component<T1,M> const &, field_component<T2,M> const &>()(left, right);
 
8938
}
 
8939
#endif // BOOST_VERSION
 
8940
template<class T1, class T2, class M>
 
8941
#if BOOST_VERSION < 104601
 
8942
typename
 
8943
boost::proto::detail::enable_binary<
 
8944
  field_domain,
 
8945
  is_field<field_component<T1,M> >,
 
8946
  field_component<T1,M>,
 
8947
  is_field<field_component_const<T2,M> >,
 
8948
  field_component_const<T2,M>,
 
8949
  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8950
    ::impl<const field_component<T1,M>&,   const field_component_const<T2,M>&>::result_type const
 
8951
>::type
 
8952
operator/ (const field_component<T1,M>& l, const field_component_const<T2,M>& r)
 
8953
{
 
8954
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8955
    ::impl<const field_component<T1,M>&, const field_component_const<T2,M>&>() (l, r);
 
8956
}
 
8957
#else // BOOST_VERSION >= 104601
 
8958
typename boost::proto::detail::enable_binary< 
 
8959
  field_domain,
 
8960
  field_domain::proto_grammar,
 
8961
  boost::mpl::and_<
 
8962
    boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_component_const<T2,M> > >,
 
8963
    boost::mpl::not_<
 
8964
      boost::mpl::or_<
 
8965
        boost::proto::is_extension<field_component<T1,M> >,
 
8966
        boost::proto::is_extension<field_component_const<T2,M> >
 
8967
      >
 
8968
    >
 
8969
  >,
 
8970
  boost::proto::tag::divides,
 
8971
  field_component<T1,M> const &,
 
8972
  field_component_const<T2,M> const &
 
8973
>::type /* const */
 
8974
operator/ (field_component<T1,M> const &left, field_component_const<T2,M> const &right)
 
8975
{
 
8976
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_component<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
 
8977
}
 
8978
#endif // BOOST_VERSION
 
8979
template<class T1, class T2, class M>
 
8980
#if BOOST_VERSION < 104601
 
8981
typename
 
8982
boost::proto::detail::enable_binary<
 
8983
  field_domain,
 
8984
  is_field<field_component_const<T1,M> >,
 
8985
  field_component_const<T1,M>,
 
8986
  is_field<field_basic<T2,M> >,
 
8987
  field_basic<T2,M>,
 
8988
  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8989
    ::impl<const field_component_const<T1,M>&,   const field_basic<T2,M>&>::result_type const
 
8990
>::type
 
8991
operator/ (const field_component_const<T1,M>& l, const field_basic<T2,M>& r)
 
8992
{
 
8993
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
8994
    ::impl<const field_component_const<T1,M>&, const field_basic<T2,M>&>() (l, r);
 
8995
}
 
8996
#else // BOOST_VERSION >= 104601
 
8997
typename boost::proto::detail::enable_binary< 
 
8998
  field_domain,
 
8999
  field_domain::proto_grammar,
 
9000
  boost::mpl::and_<
 
9001
    boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_basic<T2,M> > >,
 
9002
    boost::mpl::not_<
 
9003
      boost::mpl::or_<
 
9004
        boost::proto::is_extension<field_component_const<T1,M> >,
 
9005
        boost::proto::is_extension<field_basic<T2,M> >
 
9006
      >
 
9007
    >
 
9008
  >,
 
9009
  boost::proto::tag::divides,
 
9010
  field_component_const<T1,M> const &,
 
9011
  field_basic<T2,M> const &
 
9012
>::type /* const */
 
9013
operator/ (field_component_const<T1,M> const &left, field_basic<T2,M> const &right)
 
9014
{
 
9015
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_component_const<T1,M> const &, field_basic<T2,M> const &>()(left, right);
 
9016
}
 
9017
#endif // BOOST_VERSION
 
9018
template<class T1, class T2, class M>
 
9019
#if BOOST_VERSION < 104601
 
9020
typename
 
9021
boost::proto::detail::enable_binary<
 
9022
  field_domain,
 
9023
  is_field<field_component_const<T1,M> >,
 
9024
  field_component_const<T1,M>,
 
9025
  is_field<field_indirect<T2,M> >,
 
9026
  field_indirect<T2,M>,
 
9027
  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
9028
    ::impl<const field_component_const<T1,M>&,   const field_indirect<T2,M>&>::result_type const
 
9029
>::type
 
9030
operator/ (const field_component_const<T1,M>& l, const field_indirect<T2,M>& r)
 
9031
{
 
9032
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
9033
    ::impl<const field_component_const<T1,M>&, const field_indirect<T2,M>&>() (l, r);
 
9034
}
 
9035
#else // BOOST_VERSION >= 104601
 
9036
typename boost::proto::detail::enable_binary< 
 
9037
  field_domain,
 
9038
  field_domain::proto_grammar,
 
9039
  boost::mpl::and_<
 
9040
    boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_indirect<T2,M> > >,
 
9041
    boost::mpl::not_<
 
9042
      boost::mpl::or_<
 
9043
        boost::proto::is_extension<field_component_const<T1,M> >,
 
9044
        boost::proto::is_extension<field_indirect<T2,M> >
 
9045
      >
 
9046
    >
 
9047
  >,
 
9048
  boost::proto::tag::divides,
 
9049
  field_component_const<T1,M> const &,
 
9050
  field_indirect<T2,M> const &
 
9051
>::type /* const */
 
9052
operator/ (field_component_const<T1,M> const &left, field_indirect<T2,M> const &right)
 
9053
{
 
9054
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_component_const<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
 
9055
}
 
9056
#endif // BOOST_VERSION
 
9057
template<class T1, class T2, class M>
 
9058
#if BOOST_VERSION < 104601
 
9059
typename
 
9060
boost::proto::detail::enable_binary<
 
9061
  field_domain,
 
9062
  is_field<field_component_const<T1,M> >,
 
9063
  field_component_const<T1,M>,
 
9064
  is_field<field_indirect_const<T2,M> >,
 
9065
  field_indirect_const<T2,M>,
 
9066
  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
9067
    ::impl<const field_component_const<T1,M>&,   const field_indirect_const<T2,M>&>::result_type const
 
9068
>::type
 
9069
operator/ (const field_component_const<T1,M>& l, const field_indirect_const<T2,M>& r)
 
9070
{
 
9071
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
9072
    ::impl<const field_component_const<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
 
9073
}
 
9074
#else // BOOST_VERSION >= 104601
 
9075
typename boost::proto::detail::enable_binary< 
 
9076
  field_domain,
 
9077
  field_domain::proto_grammar,
 
9078
  boost::mpl::and_<
 
9079
    boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_indirect_const<T2,M> > >,
 
9080
    boost::mpl::not_<
 
9081
      boost::mpl::or_<
 
9082
        boost::proto::is_extension<field_component_const<T1,M> >,
 
9083
        boost::proto::is_extension<field_indirect_const<T2,M> >
 
9084
      >
 
9085
    >
 
9086
  >,
 
9087
  boost::proto::tag::divides,
 
9088
  field_component_const<T1,M> const &,
 
9089
  field_indirect_const<T2,M> const &
 
9090
>::type /* const */
 
9091
operator/ (field_component_const<T1,M> const &left, field_indirect_const<T2,M> const &right)
 
9092
{
 
9093
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_component_const<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
 
9094
}
 
9095
#endif // BOOST_VERSION
 
9096
template<class T1, class T2, class M>
 
9097
#if BOOST_VERSION < 104601
 
9098
typename
 
9099
boost::proto::detail::enable_binary<
 
9100
  field_domain,
 
9101
  is_field<field_component_const<T1,M> >,
 
9102
  field_component_const<T1,M>,
 
9103
  is_field<field_component<T2,M> >,
 
9104
  field_component<T2,M>,
 
9105
  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
9106
    ::impl<const field_component_const<T1,M>&,   const field_component<T2,M>&>::result_type const
 
9107
>::type
 
9108
operator/ (const field_component_const<T1,M>& l, const field_component<T2,M>& r)
 
9109
{
 
9110
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
9111
    ::impl<const field_component_const<T1,M>&, const field_component<T2,M>&>() (l, r);
 
9112
}
 
9113
#else // BOOST_VERSION >= 104601
 
9114
typename boost::proto::detail::enable_binary< 
 
9115
  field_domain,
 
9116
  field_domain::proto_grammar,
 
9117
  boost::mpl::and_<
 
9118
    boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_component<T2,M> > >,
 
9119
    boost::mpl::not_<
 
9120
      boost::mpl::or_<
 
9121
        boost::proto::is_extension<field_component_const<T1,M> >,
 
9122
        boost::proto::is_extension<field_component<T2,M> >
 
9123
      >
 
9124
    >
 
9125
  >,
 
9126
  boost::proto::tag::divides,
 
9127
  field_component_const<T1,M> const &,
 
9128
  field_component<T2,M> const &
 
9129
>::type /* const */
 
9130
operator/ (field_component_const<T1,M> const &left, field_component<T2,M> const &right)
 
9131
{
 
9132
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_component_const<T1,M> const &, field_component<T2,M> const &>()(left, right);
 
9133
}
 
9134
#endif // BOOST_VERSION
 
9135
template<class T1, class T2, class M>
 
9136
#if BOOST_VERSION < 104601
 
9137
typename
 
9138
boost::proto::detail::enable_binary<
 
9139
  field_domain,
 
9140
  is_field<field_component_const<T1,M> >,
 
9141
  field_component_const<T1,M>,
 
9142
  is_field<field_component_const<T2,M> >,
 
9143
  field_component_const<T2,M>,
 
9144
  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
9145
    ::impl<const field_component_const<T1,M>&,   const field_component_const<T2,M>&>::result_type const
 
9146
>::type
 
9147
operator/ (const field_component_const<T1,M>& l, const field_component_const<T2,M>& r)
 
9148
{
 
9149
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
9150
    ::impl<const field_component_const<T1,M>&, const field_component_const<T2,M>&>() (l, r);
 
9151
}
 
9152
#else // BOOST_VERSION >= 104601
 
9153
typename boost::proto::detail::enable_binary< 
 
9154
  field_domain,
 
9155
  field_domain::proto_grammar,
 
9156
  boost::mpl::and_<
 
9157
    boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_component_const<T2,M> > >,
 
9158
    boost::mpl::not_<
 
9159
      boost::mpl::or_<
 
9160
        boost::proto::is_extension<field_component_const<T1,M> >,
 
9161
        boost::proto::is_extension<field_component_const<T2,M> >
 
9162
      >
 
9163
    >
 
9164
  >,
 
9165
  boost::proto::tag::divides,
 
9166
  field_component_const<T1,M> const &,
 
9167
  field_component_const<T2,M> const &
 
9168
>::type /* const */
 
9169
operator/ (field_component_const<T1,M> const &left, field_component_const<T2,M> const &right)
 
9170
{
 
9171
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_component_const<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
 
9172
}
 
9173
#endif // BOOST_VERSION
2014
9174
template<class Expr>
 
9175
#if BOOST_VERSION < 104601
2015
9176
typename
2016
9177
boost::proto::detail::enable_binary<
2017
9178
  field_domain,
2025
9186
operator/ (const int& l, const field_expr<Expr>& r)
2026
9187
{
2027
9188
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
2028
 
    ::impl<const int&,   const field_expr<Expr>&>() (l, r);
2029
 
}
 
9189
    ::impl<const int&, const field_expr<Expr>&>() (l, r);
 
9190
}
 
9191
#else // BOOST_VERSION >= 104601
 
9192
typename boost::proto::detail::enable_binary< 
 
9193
  field_domain,
 
9194
  field_domain::proto_grammar,
 
9195
  boost::mpl::and_<
 
9196
    boost::mpl::or_<is_field<int >, is_field<field_expr<Expr> > >,
 
9197
    boost::mpl::not_<
 
9198
      boost::mpl::or_<
 
9199
        boost::proto::is_extension<int >,
 
9200
        boost::proto::is_extension<field_expr<Expr> >
 
9201
      >
 
9202
    >
 
9203
  >,
 
9204
  boost::proto::tag::divides,
 
9205
  int const &,
 
9206
  field_expr<Expr> const &
 
9207
>::type /* const */
 
9208
operator/ (int const &left, field_expr<Expr> const &right)
 
9209
{
 
9210
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, int const &, field_expr<Expr> const &>()(left, right);
 
9211
}
 
9212
#endif // BOOST_VERSION
2030
9213
template<class Expr>
 
9214
#if BOOST_VERSION < 104601
2031
9215
typename
2032
9216
boost::proto::detail::enable_binary<
2033
9217
  field_domain,
2041
9225
operator/ (const field_expr<Expr>& l, const int& r)
2042
9226
{
2043
9227
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
2044
 
    ::impl<const field_expr<Expr>&,   const int&>() (l, r);
2045
 
}
 
9228
    ::impl<const field_expr<Expr>&, const int&>() (l, r);
 
9229
}
 
9230
#else // BOOST_VERSION >= 104601
 
9231
typename boost::proto::detail::enable_binary< 
 
9232
  field_domain,
 
9233
  field_domain::proto_grammar,
 
9234
  boost::mpl::and_<
 
9235
    boost::mpl::or_<is_field<field_expr<Expr> >, is_field<int > >,
 
9236
    boost::mpl::not_<
 
9237
      boost::mpl::or_<
 
9238
        boost::proto::is_extension<field_expr<Expr> >,
 
9239
        boost::proto::is_extension<int >
 
9240
      >
 
9241
    >
 
9242
  >,
 
9243
  boost::proto::tag::divides,
 
9244
  field_expr<Expr> const &,
 
9245
  int const &
 
9246
>::type /* const */
 
9247
operator/ (field_expr<Expr> const &left, int const &right)
 
9248
{
 
9249
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_expr<Expr> const &, int const &>()(left, right);
 
9250
}
 
9251
#endif // BOOST_VERSION
2046
9252
template<class T, class Expr>
 
9253
#if BOOST_VERSION < 104601
2047
9254
typename
2048
9255
boost::proto::detail::enable_binary<
2049
9256
  field_domain,
2057
9264
operator/ (const T& l, const field_expr<Expr>& r)
2058
9265
{
2059
9266
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
2060
 
    ::impl<const T&,   const field_expr<Expr>&>() (l, r);
2061
 
}
 
9267
    ::impl<const T&, const field_expr<Expr>&>() (l, r);
 
9268
}
 
9269
#else // BOOST_VERSION >= 104601
 
9270
typename boost::proto::detail::enable_binary< 
 
9271
  field_domain,
 
9272
  field_domain::proto_grammar,
 
9273
  boost::mpl::and_<
 
9274
    boost::mpl::or_<is_field<T >, is_field<field_expr<Expr> > >,
 
9275
    boost::mpl::not_<
 
9276
      boost::mpl::or_<
 
9277
        boost::proto::is_extension<T >,
 
9278
        boost::proto::is_extension<field_expr<Expr> >
 
9279
      >
 
9280
    >
 
9281
  >,
 
9282
  boost::proto::tag::divides,
 
9283
  T const &,
 
9284
  field_expr<Expr> const &
 
9285
>::type /* const */
 
9286
operator/ (T const &left, field_expr<Expr> const &right)
 
9287
{
 
9288
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, T const &, field_expr<Expr> const &>()(left, right);
 
9289
}
 
9290
#endif // BOOST_VERSION
2062
9291
template<class T, class Expr>
 
9292
#if BOOST_VERSION < 104601
2063
9293
typename
2064
9294
boost::proto::detail::enable_binary<
2065
9295
  field_domain,
2073
9303
operator/ (const field_expr<Expr>& l, const T& r)
2074
9304
{
2075
9305
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
2076
 
    ::impl<const field_expr<Expr>&,   const T&>() (l, r);
2077
 
}
 
9306
    ::impl<const field_expr<Expr>&, const T&>() (l, r);
 
9307
}
 
9308
#else // BOOST_VERSION >= 104601
 
9309
typename boost::proto::detail::enable_binary< 
 
9310
  field_domain,
 
9311
  field_domain::proto_grammar,
 
9312
  boost::mpl::and_<
 
9313
    boost::mpl::or_<is_field<field_expr<Expr> >, is_field<T > >,
 
9314
    boost::mpl::not_<
 
9315
      boost::mpl::or_<
 
9316
        boost::proto::is_extension<field_expr<Expr> >,
 
9317
        boost::proto::is_extension<T >
 
9318
      >
 
9319
    >
 
9320
  >,
 
9321
  boost::proto::tag::divides,
 
9322
  field_expr<Expr> const &,
 
9323
  T const &
 
9324
>::type /* const */
 
9325
operator/ (field_expr<Expr> const &left, T const &right)
 
9326
{
 
9327
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_expr<Expr> const &, T const &>()(left, right);
 
9328
}
 
9329
#endif // BOOST_VERSION
2078
9330
template<class T, class M, class Expr>
 
9331
#if BOOST_VERSION < 104601
2079
9332
typename
2080
9333
boost::proto::detail::enable_binary<
2081
9334
  field_domain,
2089
9342
operator/ (const field_basic<T,M>& l, const field_expr<Expr>& r)
2090
9343
{
2091
9344
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
2092
 
    ::impl<const field_basic<T,M>&,   const field_expr<Expr>&>() (l, r);
2093
 
}
 
9345
    ::impl<const field_basic<T,M>&, const field_expr<Expr>&>() (l, r);
 
9346
}
 
9347
#else // BOOST_VERSION >= 104601
 
9348
typename boost::proto::detail::enable_binary< 
 
9349
  field_domain,
 
9350
  field_domain::proto_grammar,
 
9351
  boost::mpl::and_<
 
9352
    boost::mpl::or_<is_field<field_basic<T,M> >, is_field<field_expr<Expr> > >,
 
9353
    boost::mpl::not_<
 
9354
      boost::mpl::or_<
 
9355
        boost::proto::is_extension<field_basic<T,M> >,
 
9356
        boost::proto::is_extension<field_expr<Expr> >
 
9357
      >
 
9358
    >
 
9359
  >,
 
9360
  boost::proto::tag::divides,
 
9361
  field_basic<T,M> const &,
 
9362
  field_expr<Expr> const &
 
9363
>::type /* const */
 
9364
operator/ (field_basic<T,M> const &left, field_expr<Expr> const &right)
 
9365
{
 
9366
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_basic<T,M> const &, field_expr<Expr> const &>()(left, right);
 
9367
}
 
9368
#endif // BOOST_VERSION
2094
9369
template<class T, class M, class Expr>
 
9370
#if BOOST_VERSION < 104601
2095
9371
typename
2096
9372
boost::proto::detail::enable_binary<
2097
9373
  field_domain,
2105
9381
operator/ (const field_expr<Expr>& l, const field_basic<T,M>& r)
2106
9382
{
2107
9383
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
2108
 
    ::impl<const field_expr<Expr>&,   const field_basic<T,M>&>() (l, r);
2109
 
}
 
9384
    ::impl<const field_expr<Expr>&, const field_basic<T,M>&>() (l, r);
 
9385
}
 
9386
#else // BOOST_VERSION >= 104601
 
9387
typename boost::proto::detail::enable_binary< 
 
9388
  field_domain,
 
9389
  field_domain::proto_grammar,
 
9390
  boost::mpl::and_<
 
9391
    boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_basic<T,M> > >,
 
9392
    boost::mpl::not_<
 
9393
      boost::mpl::or_<
 
9394
        boost::proto::is_extension<field_expr<Expr> >,
 
9395
        boost::proto::is_extension<field_basic<T,M> >
 
9396
      >
 
9397
    >
 
9398
  >,
 
9399
  boost::proto::tag::divides,
 
9400
  field_expr<Expr> const &,
 
9401
  field_basic<T,M> const &
 
9402
>::type /* const */
 
9403
operator/ (field_expr<Expr> const &left, field_basic<T,M> const &right)
 
9404
{
 
9405
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_expr<Expr> const &, field_basic<T,M> const &>()(left, right);
 
9406
}
 
9407
#endif // BOOST_VERSION
2110
9408
template<class T, class M, class Expr>
 
9409
#if BOOST_VERSION < 104601
2111
9410
typename
2112
9411
boost::proto::detail::enable_binary<
2113
9412
  field_domain,
2121
9420
operator/ (const field_indirect<T,M>& l, const field_expr<Expr>& r)
2122
9421
{
2123
9422
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
2124
 
    ::impl<const field_indirect<T,M>&,   const field_expr<Expr>&>() (l, r);
2125
 
}
 
9423
    ::impl<const field_indirect<T,M>&, const field_expr<Expr>&>() (l, r);
 
9424
}
 
9425
#else // BOOST_VERSION >= 104601
 
9426
typename boost::proto::detail::enable_binary< 
 
9427
  field_domain,
 
9428
  field_domain::proto_grammar,
 
9429
  boost::mpl::and_<
 
9430
    boost::mpl::or_<is_field<field_indirect<T,M> >, is_field<field_expr<Expr> > >,
 
9431
    boost::mpl::not_<
 
9432
      boost::mpl::or_<
 
9433
        boost::proto::is_extension<field_indirect<T,M> >,
 
9434
        boost::proto::is_extension<field_expr<Expr> >
 
9435
      >
 
9436
    >
 
9437
  >,
 
9438
  boost::proto::tag::divides,
 
9439
  field_indirect<T,M> const &,
 
9440
  field_expr<Expr> const &
 
9441
>::type /* const */
 
9442
operator/ (field_indirect<T,M> const &left, field_expr<Expr> const &right)
 
9443
{
 
9444
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_indirect<T,M> const &, field_expr<Expr> const &>()(left, right);
 
9445
}
 
9446
#endif // BOOST_VERSION
2126
9447
template<class T, class M, class Expr>
 
9448
#if BOOST_VERSION < 104601
2127
9449
typename
2128
9450
boost::proto::detail::enable_binary<
2129
9451
  field_domain,
2137
9459
operator/ (const field_expr<Expr>& l, const field_indirect<T,M>& r)
2138
9460
{
2139
9461
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
2140
 
    ::impl<const field_expr<Expr>&,   const field_indirect<T,M>&>() (l, r);
2141
 
}
 
9462
    ::impl<const field_expr<Expr>&, const field_indirect<T,M>&>() (l, r);
 
9463
}
 
9464
#else // BOOST_VERSION >= 104601
 
9465
typename boost::proto::detail::enable_binary< 
 
9466
  field_domain,
 
9467
  field_domain::proto_grammar,
 
9468
  boost::mpl::and_<
 
9469
    boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_indirect<T,M> > >,
 
9470
    boost::mpl::not_<
 
9471
      boost::mpl::or_<
 
9472
        boost::proto::is_extension<field_expr<Expr> >,
 
9473
        boost::proto::is_extension<field_indirect<T,M> >
 
9474
      >
 
9475
    >
 
9476
  >,
 
9477
  boost::proto::tag::divides,
 
9478
  field_expr<Expr> const &,
 
9479
  field_indirect<T,M> const &
 
9480
>::type /* const */
 
9481
operator/ (field_expr<Expr> const &left, field_indirect<T,M> const &right)
 
9482
{
 
9483
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_expr<Expr> const &, field_indirect<T,M> const &>()(left, right);
 
9484
}
 
9485
#endif // BOOST_VERSION
2142
9486
template<class T, class M, class Expr>
 
9487
#if BOOST_VERSION < 104601
2143
9488
typename
2144
9489
boost::proto::detail::enable_binary<
2145
9490
  field_domain,
2153
9498
operator/ (const field_indirect_const<T,M>& l, const field_expr<Expr>& r)
2154
9499
{
2155
9500
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
2156
 
    ::impl<const field_indirect_const<T,M>&,   const field_expr<Expr>&>() (l, r);
2157
 
}
 
9501
    ::impl<const field_indirect_const<T,M>&, const field_expr<Expr>&>() (l, r);
 
9502
}
 
9503
#else // BOOST_VERSION >= 104601
 
9504
typename boost::proto::detail::enable_binary< 
 
9505
  field_domain,
 
9506
  field_domain::proto_grammar,
 
9507
  boost::mpl::and_<
 
9508
    boost::mpl::or_<is_field<field_indirect_const<T,M> >, is_field<field_expr<Expr> > >,
 
9509
    boost::mpl::not_<
 
9510
      boost::mpl::or_<
 
9511
        boost::proto::is_extension<field_indirect_const<T,M> >,
 
9512
        boost::proto::is_extension<field_expr<Expr> >
 
9513
      >
 
9514
    >
 
9515
  >,
 
9516
  boost::proto::tag::divides,
 
9517
  field_indirect_const<T,M> const &,
 
9518
  field_expr<Expr> const &
 
9519
>::type /* const */
 
9520
operator/ (field_indirect_const<T,M> const &left, field_expr<Expr> const &right)
 
9521
{
 
9522
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_indirect_const<T,M> const &, field_expr<Expr> const &>()(left, right);
 
9523
}
 
9524
#endif // BOOST_VERSION
2158
9525
template<class T, class M, class Expr>
 
9526
#if BOOST_VERSION < 104601
2159
9527
typename
2160
9528
boost::proto::detail::enable_binary<
2161
9529
  field_domain,
2169
9537
operator/ (const field_expr<Expr>& l, const field_indirect_const<T,M>& r)
2170
9538
{
2171
9539
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
2172
 
    ::impl<const field_expr<Expr>&,   const field_indirect_const<T,M>&>() (l, r);
2173
 
}
 
9540
    ::impl<const field_expr<Expr>&, const field_indirect_const<T,M>&>() (l, r);
 
9541
}
 
9542
#else // BOOST_VERSION >= 104601
 
9543
typename boost::proto::detail::enable_binary< 
 
9544
  field_domain,
 
9545
  field_domain::proto_grammar,
 
9546
  boost::mpl::and_<
 
9547
    boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_indirect_const<T,M> > >,
 
9548
    boost::mpl::not_<
 
9549
      boost::mpl::or_<
 
9550
        boost::proto::is_extension<field_expr<Expr> >,
 
9551
        boost::proto::is_extension<field_indirect_const<T,M> >
 
9552
      >
 
9553
    >
 
9554
  >,
 
9555
  boost::proto::tag::divides,
 
9556
  field_expr<Expr> const &,
 
9557
  field_indirect_const<T,M> const &
 
9558
>::type /* const */
 
9559
operator/ (field_expr<Expr> const &left, field_indirect_const<T,M> const &right)
 
9560
{
 
9561
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_expr<Expr> const &, field_indirect_const<T,M> const &>()(left, right);
 
9562
}
 
9563
#endif // BOOST_VERSION
 
9564
template<class T, class M, class Expr>
 
9565
#if BOOST_VERSION < 104601
 
9566
typename
 
9567
boost::proto::detail::enable_binary<
 
9568
  field_domain,
 
9569
  is_field<field_component<T,M> >,
 
9570
  field_component<T,M>,
 
9571
  is_field<field_expr<Expr> >,
 
9572
  field_expr<Expr>,
 
9573
  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
9574
    ::impl<const field_component<T,M>&,   const field_expr<Expr>&>::result_type const
 
9575
>::type
 
9576
operator/ (const field_component<T,M>& l, const field_expr<Expr>& r)
 
9577
{
 
9578
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
9579
    ::impl<const field_component<T,M>&, const field_expr<Expr>&>() (l, r);
 
9580
}
 
9581
#else // BOOST_VERSION >= 104601
 
9582
typename boost::proto::detail::enable_binary< 
 
9583
  field_domain,
 
9584
  field_domain::proto_grammar,
 
9585
  boost::mpl::and_<
 
9586
    boost::mpl::or_<is_field<field_component<T,M> >, is_field<field_expr<Expr> > >,
 
9587
    boost::mpl::not_<
 
9588
      boost::mpl::or_<
 
9589
        boost::proto::is_extension<field_component<T,M> >,
 
9590
        boost::proto::is_extension<field_expr<Expr> >
 
9591
      >
 
9592
    >
 
9593
  >,
 
9594
  boost::proto::tag::divides,
 
9595
  field_component<T,M> const &,
 
9596
  field_expr<Expr> const &
 
9597
>::type /* const */
 
9598
operator/ (field_component<T,M> const &left, field_expr<Expr> const &right)
 
9599
{
 
9600
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_component<T,M> const &, field_expr<Expr> const &>()(left, right);
 
9601
}
 
9602
#endif // BOOST_VERSION
 
9603
template<class T, class M, class Expr>
 
9604
#if BOOST_VERSION < 104601
 
9605
typename
 
9606
boost::proto::detail::enable_binary<
 
9607
  field_domain,
 
9608
  is_field<field_expr<Expr> >,
 
9609
  field_expr<Expr>,
 
9610
  is_field<field_component<T,M> >,
 
9611
  field_component<T,M>,
 
9612
  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
9613
    ::impl<const field_expr<Expr>&,   const field_component<T,M>&>::result_type const
 
9614
>::type
 
9615
operator/ (const field_expr<Expr>& l, const field_component<T,M>& r)
 
9616
{
 
9617
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
9618
    ::impl<const field_expr<Expr>&, const field_component<T,M>&>() (l, r);
 
9619
}
 
9620
#else // BOOST_VERSION >= 104601
 
9621
typename boost::proto::detail::enable_binary< 
 
9622
  field_domain,
 
9623
  field_domain::proto_grammar,
 
9624
  boost::mpl::and_<
 
9625
    boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_component<T,M> > >,
 
9626
    boost::mpl::not_<
 
9627
      boost::mpl::or_<
 
9628
        boost::proto::is_extension<field_expr<Expr> >,
 
9629
        boost::proto::is_extension<field_component<T,M> >
 
9630
      >
 
9631
    >
 
9632
  >,
 
9633
  boost::proto::tag::divides,
 
9634
  field_expr<Expr> const &,
 
9635
  field_component<T,M> const &
 
9636
>::type /* const */
 
9637
operator/ (field_expr<Expr> const &left, field_component<T,M> const &right)
 
9638
{
 
9639
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_expr<Expr> const &, field_component<T,M> const &>()(left, right);
 
9640
}
 
9641
#endif // BOOST_VERSION
 
9642
template<class T, class M, class Expr>
 
9643
#if BOOST_VERSION < 104601
 
9644
typename
 
9645
boost::proto::detail::enable_binary<
 
9646
  field_domain,
 
9647
  is_field<field_component_const<T,M> >,
 
9648
  field_component_const<T,M>,
 
9649
  is_field<field_expr<Expr> >,
 
9650
  field_expr<Expr>,
 
9651
  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
9652
    ::impl<const field_component_const<T,M>&,   const field_expr<Expr>&>::result_type const
 
9653
>::type
 
9654
operator/ (const field_component_const<T,M>& l, const field_expr<Expr>& r)
 
9655
{
 
9656
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
9657
    ::impl<const field_component_const<T,M>&, const field_expr<Expr>&>() (l, r);
 
9658
}
 
9659
#else // BOOST_VERSION >= 104601
 
9660
typename boost::proto::detail::enable_binary< 
 
9661
  field_domain,
 
9662
  field_domain::proto_grammar,
 
9663
  boost::mpl::and_<
 
9664
    boost::mpl::or_<is_field<field_component_const<T,M> >, is_field<field_expr<Expr> > >,
 
9665
    boost::mpl::not_<
 
9666
      boost::mpl::or_<
 
9667
        boost::proto::is_extension<field_component_const<T,M> >,
 
9668
        boost::proto::is_extension<field_expr<Expr> >
 
9669
      >
 
9670
    >
 
9671
  >,
 
9672
  boost::proto::tag::divides,
 
9673
  field_component_const<T,M> const &,
 
9674
  field_expr<Expr> const &
 
9675
>::type /* const */
 
9676
operator/ (field_component_const<T,M> const &left, field_expr<Expr> const &right)
 
9677
{
 
9678
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_component_const<T,M> const &, field_expr<Expr> const &>()(left, right);
 
9679
}
 
9680
#endif // BOOST_VERSION
 
9681
template<class T, class M, class Expr>
 
9682
#if BOOST_VERSION < 104601
 
9683
typename
 
9684
boost::proto::detail::enable_binary<
 
9685
  field_domain,
 
9686
  is_field<field_expr<Expr> >,
 
9687
  field_expr<Expr>,
 
9688
  is_field<field_component_const<T,M> >,
 
9689
  field_component_const<T,M>,
 
9690
  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
9691
    ::impl<const field_expr<Expr>&,   const field_component_const<T,M>&>::result_type const
 
9692
>::type
 
9693
operator/ (const field_expr<Expr>& l, const field_component_const<T,M>& r)
 
9694
{
 
9695
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
 
9696
    ::impl<const field_expr<Expr>&, const field_component_const<T,M>&>() (l, r);
 
9697
}
 
9698
#else // BOOST_VERSION >= 104601
 
9699
typename boost::proto::detail::enable_binary< 
 
9700
  field_domain,
 
9701
  field_domain::proto_grammar,
 
9702
  boost::mpl::and_<
 
9703
    boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_component_const<T,M> > >,
 
9704
    boost::mpl::not_<
 
9705
      boost::mpl::or_<
 
9706
        boost::proto::is_extension<field_expr<Expr> >,
 
9707
        boost::proto::is_extension<field_component_const<T,M> >
 
9708
      >
 
9709
    >
 
9710
  >,
 
9711
  boost::proto::tag::divides,
 
9712
  field_expr<Expr> const &,
 
9713
  field_component_const<T,M> const &
 
9714
>::type /* const */
 
9715
operator/ (field_expr<Expr> const &left, field_component_const<T,M> const &right)
 
9716
{
 
9717
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_expr<Expr> const &, field_component_const<T,M> const &>()(left, right);
 
9718
}
 
9719
#endif // BOOST_VERSION
2174
9720
template<class Expr1, class Expr2>
 
9721
#if BOOST_VERSION < 104601
2175
9722
typename
2176
9723
boost::proto::detail::enable_binary<
2177
9724
  field_domain,
2185
9732
operator/ (const field_expr<Expr1>& l, const field_expr<Expr2>& r)
2186
9733
{
2187
9734
  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
2188
 
    ::impl<const field_expr<Expr1>&,   const field_expr<Expr2>&>() (l, r);
2189
 
}
 
9735
    ::impl<const field_expr<Expr1>&, const field_expr<Expr2>&>() (l, r);
 
9736
}
 
9737
#else // BOOST_VERSION >= 104601
 
9738
typename boost::proto::detail::enable_binary< 
 
9739
  field_domain,
 
9740
  field_domain::proto_grammar,
 
9741
  boost::mpl::and_<
 
9742
    boost::mpl::or_<is_field<field_expr<Expr1> >, is_field<field_expr<Expr2> > >,
 
9743
    boost::mpl::not_<
 
9744
      boost::mpl::or_<
 
9745
        boost::proto::is_extension<field_expr<Expr1> >,
 
9746
        boost::proto::is_extension<field_expr<Expr2> >
 
9747
      >
 
9748
    >
 
9749
  >,
 
9750
  boost::proto::tag::divides,
 
9751
  field_expr<Expr1> const &,
 
9752
  field_expr<Expr2> const &
 
9753
>::type /* const */
 
9754
operator/ (field_expr<Expr1> const &left, field_expr<Expr2> const &right)
 
9755
{
 
9756
  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_expr<Expr1> const &, field_expr<Expr2> const &>()(left, right);
 
9757
}
 
9758
#endif // BOOST_VERSION
2190
9759
namespace field_detail {
2191
9760
    struct plus_assign {
2192
9761
        template<class T, class U>
2197
9766
field_basic<T,M>&
2198
9767
operator+= (field_basic<T,M>& l, const int& r)
2199
9768
{
2200
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
 
9769
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
2201
9770
  return l;
2202
9771
}
2203
9772
template<class T1, class T2, class M>
2204
9773
field_basic<T1,M>&
2205
9774
operator+= (field_basic<T1,M>& l, const T2& r)
2206
9775
{
2207
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
 
9776
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
2208
9777
  return l;
2209
9778
}
2210
9779
template<class T1, class T2, class M>
2211
9780
field_basic<T1,M>&
2212
9781
operator+= (field_basic<T1,M>& l, const field_basic<T2,M>& r)
2213
9782
{
2214
 
  check_macro (l.get_stamp() == r.get_stamp(), "incompatible spaces " << l.get_stamp()
2215
 
    << " and " << r.get_stamp() << " in field += expression");
2216
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
 
9783
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
9784
    << " and " << r.stamp() << " in field += expression");
 
9785
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
2217
9786
  return l;
2218
9787
}
2219
9788
template<class T1, class T2, class M>
2220
9789
field_basic<T1,M>&
2221
9790
operator+= (field_basic<T1,M>& l, const field_indirect<T2,M>& r)
2222
9791
{
2223
 
  check_macro (l.get_stamp() == r.get_stamp(), "incompatible spaces " << l.get_stamp()
2224
 
    << " and " << r.get_stamp() << " in field += expression");
2225
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
 
9792
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
9793
    << " and " << r.stamp() << " in field += expression");
 
9794
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
2226
9795
  return l;
2227
9796
}
2228
9797
template<class T1, class T2, class M>
2229
9798
field_basic<T1,M>&
2230
9799
operator+= (field_basic<T1,M>& l, const field_indirect_const<T2,M>& r)
2231
9800
{
2232
 
  check_macro (l.get_stamp() == r.get_stamp(), "incompatible spaces " << l.get_stamp()
2233
 
    << " and " << r.get_stamp() << " in field += expression");
2234
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
 
9801
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
9802
    << " and " << r.stamp() << " in field += expression");
 
9803
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
 
9804
  return l;
 
9805
}
 
9806
template<class T1, class T2, class M>
 
9807
field_basic<T1,M>&
 
9808
operator+= (field_basic<T1,M>& l, const field_component<T2,M>& r)
 
9809
{
 
9810
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
9811
    << " and " << r.stamp() << " in field += expression");
 
9812
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
 
9813
  return l;
 
9814
}
 
9815
template<class T1, class T2, class M>
 
9816
field_basic<T1,M>&
 
9817
operator+= (field_basic<T1,M>& l, const field_component_const<T2,M>& r)
 
9818
{
 
9819
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
9820
    << " and " << r.stamp() << " in field += expression");
 
9821
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
2235
9822
  return l;
2236
9823
}
2237
9824
template<class T, class M, class Expr>
2238
9825
field_basic<T,M>&
2239
9826
operator+= (field_basic<T,M>& l, const field_expr<Expr>& r)
2240
9827
{
2241
 
  const field_check_stamp_context check_stamp (l.get_stamp());
 
9828
  const field_check_stamp_context check_stamp (l.stamp());
2242
9829
  proto::eval (proto::as_expr<field_domain>(r), check_stamp);
2243
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
 
9830
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
2244
9831
  return l;
2245
9832
}
2246
9833
template<class T, class M>
2247
9834
field_indirect<T,M>
2248
9835
operator+= (field_indirect<T,M> l, const int& r)
2249
9836
{
2250
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
 
9837
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
2251
9838
  return l;
2252
9839
}
2253
9840
template<class T1, class T2, class M>
2254
9841
field_indirect<T1,M>
2255
9842
operator+= (field_indirect<T1,M> l, const T2& r)
2256
9843
{
2257
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
 
9844
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
2258
9845
  return l;
2259
9846
}
2260
9847
template<class T1, class T2, class M>
2261
9848
field_indirect<T1,M>
2262
9849
operator+= (field_indirect<T1,M> l, const field_basic<T2,M>& r)
2263
9850
{
2264
 
  check_macro (l.get_stamp() == r.get_stamp(), "incompatible spaces " << l.get_stamp()
2265
 
    << " and " << r.get_stamp() << " in field += expression");
2266
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
 
9851
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
9852
    << " and " << r.stamp() << " in field += expression");
 
9853
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
2267
9854
  return l;
2268
9855
}
2269
9856
template<class T1, class T2, class M>
2270
9857
field_indirect<T1,M>
2271
9858
operator+= (field_indirect<T1,M> l, const field_indirect<T2,M>& r)
2272
9859
{
2273
 
  check_macro (l.get_stamp() == r.get_stamp(), "incompatible spaces " << l.get_stamp()
2274
 
    << " and " << r.get_stamp() << " in field += expression");
2275
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
 
9860
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
9861
    << " and " << r.stamp() << " in field += expression");
 
9862
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
2276
9863
  return l;
2277
9864
}
2278
9865
template<class T1, class T2, class M>
2279
9866
field_indirect<T1,M>
2280
9867
operator+= (field_indirect<T1,M> l, const field_indirect_const<T2,M>& r)
2281
9868
{
2282
 
  check_macro (l.get_stamp() == r.get_stamp(), "incompatible spaces " << l.get_stamp()
2283
 
    << " and " << r.get_stamp() << " in field += expression");
2284
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
 
9869
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
9870
    << " and " << r.stamp() << " in field += expression");
 
9871
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
 
9872
  return l;
 
9873
}
 
9874
template<class T1, class T2, class M>
 
9875
field_indirect<T1,M>
 
9876
operator+= (field_indirect<T1,M> l, const field_component<T2,M>& r)
 
9877
{
 
9878
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
9879
    << " and " << r.stamp() << " in field += expression");
 
9880
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
 
9881
  return l;
 
9882
}
 
9883
template<class T1, class T2, class M>
 
9884
field_indirect<T1,M>
 
9885
operator+= (field_indirect<T1,M> l, const field_component_const<T2,M>& r)
 
9886
{
 
9887
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
9888
    << " and " << r.stamp() << " in field += expression");
 
9889
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
2285
9890
  return l;
2286
9891
}
2287
9892
template<class T, class M, class Expr>
2288
9893
field_indirect<T,M>
2289
9894
operator+= (field_indirect<T,M> l, const field_expr<Expr>& r)
2290
9895
{
2291
 
  const field_check_stamp_context check_stamp (l.get_stamp());
2292
 
  proto::eval (proto::as_expr<field_domain>(r), check_stamp);
2293
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
 
9896
  const field_check_stamp_context check_stamp (l.stamp());
 
9897
  proto::eval (proto::as_expr<field_domain>(r), check_stamp);
 
9898
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
 
9899
  return l;
 
9900
}
 
9901
template<class T, class M>
 
9902
field_component<T,M>
 
9903
operator+= (field_component<T,M> l, const int& r)
 
9904
{
 
9905
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
 
9906
  return l;
 
9907
}
 
9908
template<class T1, class T2, class M>
 
9909
field_component<T1,M>
 
9910
operator+= (field_component<T1,M> l, const T2& r)
 
9911
{
 
9912
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
 
9913
  return l;
 
9914
}
 
9915
template<class T1, class T2, class M>
 
9916
field_component<T1,M>
 
9917
operator+= (field_component<T1,M> l, const field_basic<T2,M>& r)
 
9918
{
 
9919
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
9920
    << " and " << r.stamp() << " in field += expression");
 
9921
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
 
9922
  return l;
 
9923
}
 
9924
template<class T1, class T2, class M>
 
9925
field_component<T1,M>
 
9926
operator+= (field_component<T1,M> l, const field_indirect<T2,M>& r)
 
9927
{
 
9928
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
9929
    << " and " << r.stamp() << " in field += expression");
 
9930
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
 
9931
  return l;
 
9932
}
 
9933
template<class T1, class T2, class M>
 
9934
field_component<T1,M>
 
9935
operator+= (field_component<T1,M> l, const field_indirect_const<T2,M>& r)
 
9936
{
 
9937
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
9938
    << " and " << r.stamp() << " in field += expression");
 
9939
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
 
9940
  return l;
 
9941
}
 
9942
template<class T1, class T2, class M>
 
9943
field_component<T1,M>
 
9944
operator+= (field_component<T1,M> l, const field_component<T2,M>& r)
 
9945
{
 
9946
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
9947
    << " and " << r.stamp() << " in field += expression");
 
9948
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
 
9949
  return l;
 
9950
}
 
9951
template<class T1, class T2, class M>
 
9952
field_component<T1,M>
 
9953
operator+= (field_component<T1,M> l, const field_component_const<T2,M>& r)
 
9954
{
 
9955
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
9956
    << " and " << r.stamp() << " in field += expression");
 
9957
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
 
9958
  return l;
 
9959
}
 
9960
template<class T, class M, class Expr>
 
9961
field_component<T,M>
 
9962
operator+= (field_component<T,M> l, const field_expr<Expr>& r)
 
9963
{
 
9964
  const field_check_stamp_context check_stamp (l.stamp());
 
9965
  proto::eval (proto::as_expr<field_domain>(r), check_stamp);
 
9966
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::plus_assign());
2294
9967
  return l;
2295
9968
}
2296
9969
namespace field_detail {
2303
9976
field_basic<T,M>&
2304
9977
operator-= (field_basic<T,M>& l, const int& r)
2305
9978
{
2306
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
 
9979
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
2307
9980
  return l;
2308
9981
}
2309
9982
template<class T1, class T2, class M>
2310
9983
field_basic<T1,M>&
2311
9984
operator-= (field_basic<T1,M>& l, const T2& r)
2312
9985
{
2313
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
 
9986
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
2314
9987
  return l;
2315
9988
}
2316
9989
template<class T1, class T2, class M>
2317
9990
field_basic<T1,M>&
2318
9991
operator-= (field_basic<T1,M>& l, const field_basic<T2,M>& r)
2319
9992
{
2320
 
  check_macro (l.get_stamp() == r.get_stamp(), "incompatible spaces " << l.get_stamp()
2321
 
    << " and " << r.get_stamp() << " in field -= expression");
2322
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
 
9993
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
9994
    << " and " << r.stamp() << " in field -= expression");
 
9995
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
2323
9996
  return l;
2324
9997
}
2325
9998
template<class T1, class T2, class M>
2326
9999
field_basic<T1,M>&
2327
10000
operator-= (field_basic<T1,M>& l, const field_indirect<T2,M>& r)
2328
10001
{
2329
 
  check_macro (l.get_stamp() == r.get_stamp(), "incompatible spaces " << l.get_stamp()
2330
 
    << " and " << r.get_stamp() << " in field -= expression");
2331
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
 
10002
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10003
    << " and " << r.stamp() << " in field -= expression");
 
10004
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
2332
10005
  return l;
2333
10006
}
2334
10007
template<class T1, class T2, class M>
2335
10008
field_basic<T1,M>&
2336
10009
operator-= (field_basic<T1,M>& l, const field_indirect_const<T2,M>& r)
2337
10010
{
2338
 
  check_macro (l.get_stamp() == r.get_stamp(), "incompatible spaces " << l.get_stamp()
2339
 
    << " and " << r.get_stamp() << " in field -= expression");
2340
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
 
10011
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10012
    << " and " << r.stamp() << " in field -= expression");
 
10013
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
 
10014
  return l;
 
10015
}
 
10016
template<class T1, class T2, class M>
 
10017
field_basic<T1,M>&
 
10018
operator-= (field_basic<T1,M>& l, const field_component<T2,M>& r)
 
10019
{
 
10020
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10021
    << " and " << r.stamp() << " in field -= expression");
 
10022
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
 
10023
  return l;
 
10024
}
 
10025
template<class T1, class T2, class M>
 
10026
field_basic<T1,M>&
 
10027
operator-= (field_basic<T1,M>& l, const field_component_const<T2,M>& r)
 
10028
{
 
10029
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10030
    << " and " << r.stamp() << " in field -= expression");
 
10031
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
2341
10032
  return l;
2342
10033
}
2343
10034
template<class T, class M, class Expr>
2344
10035
field_basic<T,M>&
2345
10036
operator-= (field_basic<T,M>& l, const field_expr<Expr>& r)
2346
10037
{
2347
 
  const field_check_stamp_context check_stamp (l.get_stamp());
 
10038
  const field_check_stamp_context check_stamp (l.stamp());
2348
10039
  proto::eval (proto::as_expr<field_domain>(r), check_stamp);
2349
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
 
10040
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
2350
10041
  return l;
2351
10042
}
2352
10043
template<class T, class M>
2353
10044
field_indirect<T,M>
2354
10045
operator-= (field_indirect<T,M> l, const int& r)
2355
10046
{
2356
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
 
10047
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
2357
10048
  return l;
2358
10049
}
2359
10050
template<class T1, class T2, class M>
2360
10051
field_indirect<T1,M>
2361
10052
operator-= (field_indirect<T1,M> l, const T2& r)
2362
10053
{
2363
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
 
10054
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
2364
10055
  return l;
2365
10056
}
2366
10057
template<class T1, class T2, class M>
2367
10058
field_indirect<T1,M>
2368
10059
operator-= (field_indirect<T1,M> l, const field_basic<T2,M>& r)
2369
10060
{
2370
 
  check_macro (l.get_stamp() == r.get_stamp(), "incompatible spaces " << l.get_stamp()
2371
 
    << " and " << r.get_stamp() << " in field -= expression");
2372
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
 
10061
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10062
    << " and " << r.stamp() << " in field -= expression");
 
10063
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
2373
10064
  return l;
2374
10065
}
2375
10066
template<class T1, class T2, class M>
2376
10067
field_indirect<T1,M>
2377
10068
operator-= (field_indirect<T1,M> l, const field_indirect<T2,M>& r)
2378
10069
{
2379
 
  check_macro (l.get_stamp() == r.get_stamp(), "incompatible spaces " << l.get_stamp()
2380
 
    << " and " << r.get_stamp() << " in field -= expression");
2381
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
 
10070
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10071
    << " and " << r.stamp() << " in field -= expression");
 
10072
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
2382
10073
  return l;
2383
10074
}
2384
10075
template<class T1, class T2, class M>
2385
10076
field_indirect<T1,M>
2386
10077
operator-= (field_indirect<T1,M> l, const field_indirect_const<T2,M>& r)
2387
10078
{
2388
 
  check_macro (l.get_stamp() == r.get_stamp(), "incompatible spaces " << l.get_stamp()
2389
 
    << " and " << r.get_stamp() << " in field -= expression");
2390
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
 
10079
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10080
    << " and " << r.stamp() << " in field -= expression");
 
10081
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
 
10082
  return l;
 
10083
}
 
10084
template<class T1, class T2, class M>
 
10085
field_indirect<T1,M>
 
10086
operator-= (field_indirect<T1,M> l, const field_component<T2,M>& r)
 
10087
{
 
10088
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10089
    << " and " << r.stamp() << " in field -= expression");
 
10090
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
 
10091
  return l;
 
10092
}
 
10093
template<class T1, class T2, class M>
 
10094
field_indirect<T1,M>
 
10095
operator-= (field_indirect<T1,M> l, const field_component_const<T2,M>& r)
 
10096
{
 
10097
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10098
    << " and " << r.stamp() << " in field -= expression");
 
10099
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
2391
10100
  return l;
2392
10101
}
2393
10102
template<class T, class M, class Expr>
2394
10103
field_indirect<T,M>
2395
10104
operator-= (field_indirect<T,M> l, const field_expr<Expr>& r)
2396
10105
{
2397
 
  const field_check_stamp_context check_stamp (l.get_stamp());
2398
 
  proto::eval (proto::as_expr<field_domain>(r), check_stamp);
2399
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
 
10106
  const field_check_stamp_context check_stamp (l.stamp());
 
10107
  proto::eval (proto::as_expr<field_domain>(r), check_stamp);
 
10108
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
 
10109
  return l;
 
10110
}
 
10111
template<class T, class M>
 
10112
field_component<T,M>
 
10113
operator-= (field_component<T,M> l, const int& r)
 
10114
{
 
10115
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
 
10116
  return l;
 
10117
}
 
10118
template<class T1, class T2, class M>
 
10119
field_component<T1,M>
 
10120
operator-= (field_component<T1,M> l, const T2& r)
 
10121
{
 
10122
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
 
10123
  return l;
 
10124
}
 
10125
template<class T1, class T2, class M>
 
10126
field_component<T1,M>
 
10127
operator-= (field_component<T1,M> l, const field_basic<T2,M>& r)
 
10128
{
 
10129
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10130
    << " and " << r.stamp() << " in field -= expression");
 
10131
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
 
10132
  return l;
 
10133
}
 
10134
template<class T1, class T2, class M>
 
10135
field_component<T1,M>
 
10136
operator-= (field_component<T1,M> l, const field_indirect<T2,M>& r)
 
10137
{
 
10138
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10139
    << " and " << r.stamp() << " in field -= expression");
 
10140
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
 
10141
  return l;
 
10142
}
 
10143
template<class T1, class T2, class M>
 
10144
field_component<T1,M>
 
10145
operator-= (field_component<T1,M> l, const field_indirect_const<T2,M>& r)
 
10146
{
 
10147
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10148
    << " and " << r.stamp() << " in field -= expression");
 
10149
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
 
10150
  return l;
 
10151
}
 
10152
template<class T1, class T2, class M>
 
10153
field_component<T1,M>
 
10154
operator-= (field_component<T1,M> l, const field_component<T2,M>& r)
 
10155
{
 
10156
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10157
    << " and " << r.stamp() << " in field -= expression");
 
10158
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
 
10159
  return l;
 
10160
}
 
10161
template<class T1, class T2, class M>
 
10162
field_component<T1,M>
 
10163
operator-= (field_component<T1,M> l, const field_component_const<T2,M>& r)
 
10164
{
 
10165
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10166
    << " and " << r.stamp() << " in field -= expression");
 
10167
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
 
10168
  return l;
 
10169
}
 
10170
template<class T, class M, class Expr>
 
10171
field_component<T,M>
 
10172
operator-= (field_component<T,M> l, const field_expr<Expr>& r)
 
10173
{
 
10174
  const field_check_stamp_context check_stamp (l.stamp());
 
10175
  proto::eval (proto::as_expr<field_domain>(r), check_stamp);
 
10176
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::minus_assign());
2400
10177
  return l;
2401
10178
}
2402
10179
namespace field_detail {
2409
10186
field_basic<T,M>&
2410
10187
operator*= (field_basic<T,M>& l, const int& r)
2411
10188
{
2412
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
 
10189
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
2413
10190
  return l;
2414
10191
}
2415
10192
template<class T1, class T2, class M>
2416
10193
field_basic<T1,M>&
2417
10194
operator*= (field_basic<T1,M>& l, const T2& r)
2418
10195
{
2419
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
 
10196
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
2420
10197
  return l;
2421
10198
}
2422
10199
template<class T1, class T2, class M>
2423
10200
field_basic<T1,M>&
2424
10201
operator*= (field_basic<T1,M>& l, const field_basic<T2,M>& r)
2425
10202
{
2426
 
  check_macro (l.get_stamp() == r.get_stamp(), "incompatible spaces " << l.get_stamp()
2427
 
    << " and " << r.get_stamp() << " in field *= expression");
2428
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
 
10203
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10204
    << " and " << r.stamp() << " in field *= expression");
 
10205
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
2429
10206
  return l;
2430
10207
}
2431
10208
template<class T1, class T2, class M>
2432
10209
field_basic<T1,M>&
2433
10210
operator*= (field_basic<T1,M>& l, const field_indirect<T2,M>& r)
2434
10211
{
2435
 
  check_macro (l.get_stamp() == r.get_stamp(), "incompatible spaces " << l.get_stamp()
2436
 
    << " and " << r.get_stamp() << " in field *= expression");
2437
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
 
10212
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10213
    << " and " << r.stamp() << " in field *= expression");
 
10214
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
2438
10215
  return l;
2439
10216
}
2440
10217
template<class T1, class T2, class M>
2441
10218
field_basic<T1,M>&
2442
10219
operator*= (field_basic<T1,M>& l, const field_indirect_const<T2,M>& r)
2443
10220
{
2444
 
  check_macro (l.get_stamp() == r.get_stamp(), "incompatible spaces " << l.get_stamp()
2445
 
    << " and " << r.get_stamp() << " in field *= expression");
2446
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
 
10221
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10222
    << " and " << r.stamp() << " in field *= expression");
 
10223
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
 
10224
  return l;
 
10225
}
 
10226
template<class T1, class T2, class M>
 
10227
field_basic<T1,M>&
 
10228
operator*= (field_basic<T1,M>& l, const field_component<T2,M>& r)
 
10229
{
 
10230
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10231
    << " and " << r.stamp() << " in field *= expression");
 
10232
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
 
10233
  return l;
 
10234
}
 
10235
template<class T1, class T2, class M>
 
10236
field_basic<T1,M>&
 
10237
operator*= (field_basic<T1,M>& l, const field_component_const<T2,M>& r)
 
10238
{
 
10239
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10240
    << " and " << r.stamp() << " in field *= expression");
 
10241
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
2447
10242
  return l;
2448
10243
}
2449
10244
template<class T, class M, class Expr>
2450
10245
field_basic<T,M>&
2451
10246
operator*= (field_basic<T,M>& l, const field_expr<Expr>& r)
2452
10247
{
2453
 
  const field_check_stamp_context check_stamp (l.get_stamp());
 
10248
  const field_check_stamp_context check_stamp (l.stamp());
2454
10249
  proto::eval (proto::as_expr<field_domain>(r), check_stamp);
2455
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
 
10250
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
2456
10251
  return l;
2457
10252
}
2458
10253
template<class T, class M>
2459
10254
field_indirect<T,M>
2460
10255
operator*= (field_indirect<T,M> l, const int& r)
2461
10256
{
2462
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
 
10257
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
2463
10258
  return l;
2464
10259
}
2465
10260
template<class T1, class T2, class M>
2466
10261
field_indirect<T1,M>
2467
10262
operator*= (field_indirect<T1,M> l, const T2& r)
2468
10263
{
2469
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
 
10264
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
2470
10265
  return l;
2471
10266
}
2472
10267
template<class T1, class T2, class M>
2473
10268
field_indirect<T1,M>
2474
10269
operator*= (field_indirect<T1,M> l, const field_basic<T2,M>& r)
2475
10270
{
2476
 
  check_macro (l.get_stamp() == r.get_stamp(), "incompatible spaces " << l.get_stamp()
2477
 
    << " and " << r.get_stamp() << " in field *= expression");
2478
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
 
10271
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10272
    << " and " << r.stamp() << " in field *= expression");
 
10273
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
2479
10274
  return l;
2480
10275
}
2481
10276
template<class T1, class T2, class M>
2482
10277
field_indirect<T1,M>
2483
10278
operator*= (field_indirect<T1,M> l, const field_indirect<T2,M>& r)
2484
10279
{
2485
 
  check_macro (l.get_stamp() == r.get_stamp(), "incompatible spaces " << l.get_stamp()
2486
 
    << " and " << r.get_stamp() << " in field *= expression");
2487
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
 
10280
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10281
    << " and " << r.stamp() << " in field *= expression");
 
10282
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
2488
10283
  return l;
2489
10284
}
2490
10285
template<class T1, class T2, class M>
2491
10286
field_indirect<T1,M>
2492
10287
operator*= (field_indirect<T1,M> l, const field_indirect_const<T2,M>& r)
2493
10288
{
2494
 
  check_macro (l.get_stamp() == r.get_stamp(), "incompatible spaces " << l.get_stamp()
2495
 
    << " and " << r.get_stamp() << " in field *= expression");
2496
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
 
10289
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10290
    << " and " << r.stamp() << " in field *= expression");
 
10291
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
 
10292
  return l;
 
10293
}
 
10294
template<class T1, class T2, class M>
 
10295
field_indirect<T1,M>
 
10296
operator*= (field_indirect<T1,M> l, const field_component<T2,M>& r)
 
10297
{
 
10298
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10299
    << " and " << r.stamp() << " in field *= expression");
 
10300
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
 
10301
  return l;
 
10302
}
 
10303
template<class T1, class T2, class M>
 
10304
field_indirect<T1,M>
 
10305
operator*= (field_indirect<T1,M> l, const field_component_const<T2,M>& r)
 
10306
{
 
10307
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10308
    << " and " << r.stamp() << " in field *= expression");
 
10309
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
2497
10310
  return l;
2498
10311
}
2499
10312
template<class T, class M, class Expr>
2500
10313
field_indirect<T,M>
2501
10314
operator*= (field_indirect<T,M> l, const field_expr<Expr>& r)
2502
10315
{
2503
 
  const field_check_stamp_context check_stamp (l.get_stamp());
2504
 
  proto::eval (proto::as_expr<field_domain>(r), check_stamp);
2505
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
 
10316
  const field_check_stamp_context check_stamp (l.stamp());
 
10317
  proto::eval (proto::as_expr<field_domain>(r), check_stamp);
 
10318
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
 
10319
  return l;
 
10320
}
 
10321
template<class T, class M>
 
10322
field_component<T,M>
 
10323
operator*= (field_component<T,M> l, const int& r)
 
10324
{
 
10325
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
 
10326
  return l;
 
10327
}
 
10328
template<class T1, class T2, class M>
 
10329
field_component<T1,M>
 
10330
operator*= (field_component<T1,M> l, const T2& r)
 
10331
{
 
10332
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
 
10333
  return l;
 
10334
}
 
10335
template<class T1, class T2, class M>
 
10336
field_component<T1,M>
 
10337
operator*= (field_component<T1,M> l, const field_basic<T2,M>& r)
 
10338
{
 
10339
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10340
    << " and " << r.stamp() << " in field *= expression");
 
10341
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
 
10342
  return l;
 
10343
}
 
10344
template<class T1, class T2, class M>
 
10345
field_component<T1,M>
 
10346
operator*= (field_component<T1,M> l, const field_indirect<T2,M>& r)
 
10347
{
 
10348
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10349
    << " and " << r.stamp() << " in field *= expression");
 
10350
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
 
10351
  return l;
 
10352
}
 
10353
template<class T1, class T2, class M>
 
10354
field_component<T1,M>
 
10355
operator*= (field_component<T1,M> l, const field_indirect_const<T2,M>& r)
 
10356
{
 
10357
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10358
    << " and " << r.stamp() << " in field *= expression");
 
10359
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
 
10360
  return l;
 
10361
}
 
10362
template<class T1, class T2, class M>
 
10363
field_component<T1,M>
 
10364
operator*= (field_component<T1,M> l, const field_component<T2,M>& r)
 
10365
{
 
10366
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10367
    << " and " << r.stamp() << " in field *= expression");
 
10368
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
 
10369
  return l;
 
10370
}
 
10371
template<class T1, class T2, class M>
 
10372
field_component<T1,M>
 
10373
operator*= (field_component<T1,M> l, const field_component_const<T2,M>& r)
 
10374
{
 
10375
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10376
    << " and " << r.stamp() << " in field *= expression");
 
10377
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
 
10378
  return l;
 
10379
}
 
10380
template<class T, class M, class Expr>
 
10381
field_component<T,M>
 
10382
operator*= (field_component<T,M> l, const field_expr<Expr>& r)
 
10383
{
 
10384
  const field_check_stamp_context check_stamp (l.stamp());
 
10385
  proto::eval (proto::as_expr<field_domain>(r), check_stamp);
 
10386
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::multiplies_assign());
2506
10387
  return l;
2507
10388
}
2508
10389
namespace field_detail {
2515
10396
field_basic<T,M>&
2516
10397
operator/= (field_basic<T,M>& l, const int& r)
2517
10398
{
2518
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
 
10399
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
2519
10400
  return l;
2520
10401
}
2521
10402
template<class T1, class T2, class M>
2522
10403
field_basic<T1,M>&
2523
10404
operator/= (field_basic<T1,M>& l, const T2& r)
2524
10405
{
2525
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
 
10406
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
2526
10407
  return l;
2527
10408
}
2528
10409
template<class T1, class T2, class M>
2529
10410
field_basic<T1,M>&
2530
10411
operator/= (field_basic<T1,M>& l, const field_basic<T2,M>& r)
2531
10412
{
2532
 
  check_macro (l.get_stamp() == r.get_stamp(), "incompatible spaces " << l.get_stamp()
2533
 
    << " and " << r.get_stamp() << " in field /= expression");
2534
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
 
10413
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10414
    << " and " << r.stamp() << " in field /= expression");
 
10415
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
2535
10416
  return l;
2536
10417
}
2537
10418
template<class T1, class T2, class M>
2538
10419
field_basic<T1,M>&
2539
10420
operator/= (field_basic<T1,M>& l, const field_indirect<T2,M>& r)
2540
10421
{
2541
 
  check_macro (l.get_stamp() == r.get_stamp(), "incompatible spaces " << l.get_stamp()
2542
 
    << " and " << r.get_stamp() << " in field /= expression");
2543
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
 
10422
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10423
    << " and " << r.stamp() << " in field /= expression");
 
10424
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
2544
10425
  return l;
2545
10426
}
2546
10427
template<class T1, class T2, class M>
2547
10428
field_basic<T1,M>&
2548
10429
operator/= (field_basic<T1,M>& l, const field_indirect_const<T2,M>& r)
2549
10430
{
2550
 
  check_macro (l.get_stamp() == r.get_stamp(), "incompatible spaces " << l.get_stamp()
2551
 
    << " and " << r.get_stamp() << " in field /= expression");
2552
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
 
10431
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10432
    << " and " << r.stamp() << " in field /= expression");
 
10433
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
 
10434
  return l;
 
10435
}
 
10436
template<class T1, class T2, class M>
 
10437
field_basic<T1,M>&
 
10438
operator/= (field_basic<T1,M>& l, const field_component<T2,M>& r)
 
10439
{
 
10440
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10441
    << " and " << r.stamp() << " in field /= expression");
 
10442
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
 
10443
  return l;
 
10444
}
 
10445
template<class T1, class T2, class M>
 
10446
field_basic<T1,M>&
 
10447
operator/= (field_basic<T1,M>& l, const field_component_const<T2,M>& r)
 
10448
{
 
10449
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10450
    << " and " << r.stamp() << " in field /= expression");
 
10451
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
2553
10452
  return l;
2554
10453
}
2555
10454
template<class T, class M, class Expr>
2556
10455
field_basic<T,M>&
2557
10456
operator/= (field_basic<T,M>& l, const field_expr<Expr>& r)
2558
10457
{
2559
 
  const field_check_stamp_context check_stamp (l.get_stamp());
 
10458
  const field_check_stamp_context check_stamp (l.stamp());
2560
10459
  proto::eval (proto::as_expr<field_domain>(r), check_stamp);
2561
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
 
10460
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
2562
10461
  return l;
2563
10462
}
2564
10463
template<class T, class M>
2565
10464
field_indirect<T,M>
2566
10465
operator/= (field_indirect<T,M> l, const int& r)
2567
10466
{
2568
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
 
10467
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
2569
10468
  return l;
2570
10469
}
2571
10470
template<class T1, class T2, class M>
2572
10471
field_indirect<T1,M>
2573
10472
operator/= (field_indirect<T1,M> l, const T2& r)
2574
10473
{
2575
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
 
10474
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
2576
10475
  return l;
2577
10476
}
2578
10477
template<class T1, class T2, class M>
2579
10478
field_indirect<T1,M>
2580
10479
operator/= (field_indirect<T1,M> l, const field_basic<T2,M>& r)
2581
10480
{
2582
 
  check_macro (l.get_stamp() == r.get_stamp(), "incompatible spaces " << l.get_stamp()
2583
 
    << " and " << r.get_stamp() << " in field /= expression");
2584
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
 
10481
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10482
    << " and " << r.stamp() << " in field /= expression");
 
10483
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
2585
10484
  return l;
2586
10485
}
2587
10486
template<class T1, class T2, class M>
2588
10487
field_indirect<T1,M>
2589
10488
operator/= (field_indirect<T1,M> l, const field_indirect<T2,M>& r)
2590
10489
{
2591
 
  check_macro (l.get_stamp() == r.get_stamp(), "incompatible spaces " << l.get_stamp()
2592
 
    << " and " << r.get_stamp() << " in field /= expression");
2593
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
 
10490
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10491
    << " and " << r.stamp() << " in field /= expression");
 
10492
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
2594
10493
  return l;
2595
10494
}
2596
10495
template<class T1, class T2, class M>
2597
10496
field_indirect<T1,M>
2598
10497
operator/= (field_indirect<T1,M> l, const field_indirect_const<T2,M>& r)
2599
10498
{
2600
 
  check_macro (l.get_stamp() == r.get_stamp(), "incompatible spaces " << l.get_stamp()
2601
 
    << " and " << r.get_stamp() << " in field /= expression");
2602
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
 
10499
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10500
    << " and " << r.stamp() << " in field /= expression");
 
10501
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
 
10502
  return l;
 
10503
}
 
10504
template<class T1, class T2, class M>
 
10505
field_indirect<T1,M>
 
10506
operator/= (field_indirect<T1,M> l, const field_component<T2,M>& r)
 
10507
{
 
10508
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10509
    << " and " << r.stamp() << " in field /= expression");
 
10510
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
 
10511
  return l;
 
10512
}
 
10513
template<class T1, class T2, class M>
 
10514
field_indirect<T1,M>
 
10515
operator/= (field_indirect<T1,M> l, const field_component_const<T2,M>& r)
 
10516
{
 
10517
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10518
    << " and " << r.stamp() << " in field /= expression");
 
10519
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
2603
10520
  return l;
2604
10521
}
2605
10522
template<class T, class M, class Expr>
2606
10523
field_indirect<T,M>
2607
10524
operator/= (field_indirect<T,M> l, const field_expr<Expr>& r)
2608
10525
{
2609
 
  const field_check_stamp_context check_stamp (l.get_stamp());
2610
 
  proto::eval (proto::as_expr<field_domain>(r), check_stamp);
2611
 
  field_detail::evaluate (l.begin(), l.end(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
 
10526
  const field_check_stamp_context check_stamp (l.stamp());
 
10527
  proto::eval (proto::as_expr<field_domain>(r), check_stamp);
 
10528
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
 
10529
  return l;
 
10530
}
 
10531
template<class T, class M>
 
10532
field_component<T,M>
 
10533
operator/= (field_component<T,M> l, const int& r)
 
10534
{
 
10535
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
 
10536
  return l;
 
10537
}
 
10538
template<class T1, class T2, class M>
 
10539
field_component<T1,M>
 
10540
operator/= (field_component<T1,M> l, const T2& r)
 
10541
{
 
10542
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
 
10543
  return l;
 
10544
}
 
10545
template<class T1, class T2, class M>
 
10546
field_component<T1,M>
 
10547
operator/= (field_component<T1,M> l, const field_basic<T2,M>& r)
 
10548
{
 
10549
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10550
    << " and " << r.stamp() << " in field /= expression");
 
10551
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
 
10552
  return l;
 
10553
}
 
10554
template<class T1, class T2, class M>
 
10555
field_component<T1,M>
 
10556
operator/= (field_component<T1,M> l, const field_indirect<T2,M>& r)
 
10557
{
 
10558
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10559
    << " and " << r.stamp() << " in field /= expression");
 
10560
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
 
10561
  return l;
 
10562
}
 
10563
template<class T1, class T2, class M>
 
10564
field_component<T1,M>
 
10565
operator/= (field_component<T1,M> l, const field_indirect_const<T2,M>& r)
 
10566
{
 
10567
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10568
    << " and " << r.stamp() << " in field /= expression");
 
10569
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
 
10570
  return l;
 
10571
}
 
10572
template<class T1, class T2, class M>
 
10573
field_component<T1,M>
 
10574
operator/= (field_component<T1,M> l, const field_component<T2,M>& r)
 
10575
{
 
10576
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10577
    << " and " << r.stamp() << " in field /= expression");
 
10578
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
 
10579
  return l;
 
10580
}
 
10581
template<class T1, class T2, class M>
 
10582
field_component<T1,M>
 
10583
operator/= (field_component<T1,M> l, const field_component_const<T2,M>& r)
 
10584
{
 
10585
  check_macro (l.stamp() == r.stamp(), "incompatible spaces " << l.stamp()
 
10586
    << " and " << r.stamp() << " in field /= expression");
 
10587
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
 
10588
  return l;
 
10589
}
 
10590
template<class T, class M, class Expr>
 
10591
field_component<T,M>
 
10592
operator/= (field_component<T,M> l, const field_expr<Expr>& r)
 
10593
{
 
10594
  const field_check_stamp_context check_stamp (l.stamp());
 
10595
  proto::eval (proto::as_expr<field_domain>(r), check_stamp);
 
10596
  field_detail::evaluate (l.begin_dof(), l.end_dof(), proto::as_expr<field_domain>(r), field_detail::divides_assign());
2612
10597
  return l;
2613
10598
}
2614
10599
namespace field_detail {
2656
10641
{
2657
10642
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::cos_(), boost::ref(x));
2658
10643
}
 
10644
template<class T, class M>
 
10645
typename boost::proto::result_of::make_expr<
 
10646
    boost::proto::tag::function,
 
10647
    field_domain,
 
10648
    const field_detail::cos_,
 
10649
    const field_component<T,M>&
 
10650
  >::type
 
10651
cos (const field_component<T,M>& x)
 
10652
{
 
10653
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::cos_(), boost::ref(x));
 
10654
}
 
10655
template<class T, class M>
 
10656
typename boost::proto::result_of::make_expr<
 
10657
    boost::proto::tag::function,
 
10658
    field_domain,
 
10659
    const field_detail::cos_,
 
10660
    const field_component_const<T,M>&
 
10661
  >::type
 
10662
cos (const field_component_const<T,M>& x)
 
10663
{
 
10664
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::cos_(), boost::ref(x));
 
10665
}
2659
10666
template<class Expr>
2660
10667
typename boost::proto::result_of::make_expr<
2661
10668
    boost::proto::tag::function,
2712
10719
{
2713
10720
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::sin_(), boost::ref(x));
2714
10721
}
 
10722
template<class T, class M>
 
10723
typename boost::proto::result_of::make_expr<
 
10724
    boost::proto::tag::function,
 
10725
    field_domain,
 
10726
    const field_detail::sin_,
 
10727
    const field_component<T,M>&
 
10728
  >::type
 
10729
sin (const field_component<T,M>& x)
 
10730
{
 
10731
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::sin_(), boost::ref(x));
 
10732
}
 
10733
template<class T, class M>
 
10734
typename boost::proto::result_of::make_expr<
 
10735
    boost::proto::tag::function,
 
10736
    field_domain,
 
10737
    const field_detail::sin_,
 
10738
    const field_component_const<T,M>&
 
10739
  >::type
 
10740
sin (const field_component_const<T,M>& x)
 
10741
{
 
10742
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::sin_(), boost::ref(x));
 
10743
}
2715
10744
template<class Expr>
2716
10745
typename boost::proto::result_of::make_expr<
2717
10746
    boost::proto::tag::function,
2768
10797
{
2769
10798
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::tan_(), boost::ref(x));
2770
10799
}
 
10800
template<class T, class M>
 
10801
typename boost::proto::result_of::make_expr<
 
10802
    boost::proto::tag::function,
 
10803
    field_domain,
 
10804
    const field_detail::tan_,
 
10805
    const field_component<T,M>&
 
10806
  >::type
 
10807
tan (const field_component<T,M>& x)
 
10808
{
 
10809
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::tan_(), boost::ref(x));
 
10810
}
 
10811
template<class T, class M>
 
10812
typename boost::proto::result_of::make_expr<
 
10813
    boost::proto::tag::function,
 
10814
    field_domain,
 
10815
    const field_detail::tan_,
 
10816
    const field_component_const<T,M>&
 
10817
  >::type
 
10818
tan (const field_component_const<T,M>& x)
 
10819
{
 
10820
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::tan_(), boost::ref(x));
 
10821
}
2771
10822
template<class Expr>
2772
10823
typename boost::proto::result_of::make_expr<
2773
10824
    boost::proto::tag::function,
2824
10875
{
2825
10876
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::acos_(), boost::ref(x));
2826
10877
}
 
10878
template<class T, class M>
 
10879
typename boost::proto::result_of::make_expr<
 
10880
    boost::proto::tag::function,
 
10881
    field_domain,
 
10882
    const field_detail::acos_,
 
10883
    const field_component<T,M>&
 
10884
  >::type
 
10885
acos (const field_component<T,M>& x)
 
10886
{
 
10887
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::acos_(), boost::ref(x));
 
10888
}
 
10889
template<class T, class M>
 
10890
typename boost::proto::result_of::make_expr<
 
10891
    boost::proto::tag::function,
 
10892
    field_domain,
 
10893
    const field_detail::acos_,
 
10894
    const field_component_const<T,M>&
 
10895
  >::type
 
10896
acos (const field_component_const<T,M>& x)
 
10897
{
 
10898
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::acos_(), boost::ref(x));
 
10899
}
2827
10900
template<class Expr>
2828
10901
typename boost::proto::result_of::make_expr<
2829
10902
    boost::proto::tag::function,
2880
10953
{
2881
10954
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::asin_(), boost::ref(x));
2882
10955
}
 
10956
template<class T, class M>
 
10957
typename boost::proto::result_of::make_expr<
 
10958
    boost::proto::tag::function,
 
10959
    field_domain,
 
10960
    const field_detail::asin_,
 
10961
    const field_component<T,M>&
 
10962
  >::type
 
10963
asin (const field_component<T,M>& x)
 
10964
{
 
10965
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::asin_(), boost::ref(x));
 
10966
}
 
10967
template<class T, class M>
 
10968
typename boost::proto::result_of::make_expr<
 
10969
    boost::proto::tag::function,
 
10970
    field_domain,
 
10971
    const field_detail::asin_,
 
10972
    const field_component_const<T,M>&
 
10973
  >::type
 
10974
asin (const field_component_const<T,M>& x)
 
10975
{
 
10976
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::asin_(), boost::ref(x));
 
10977
}
2883
10978
template<class Expr>
2884
10979
typename boost::proto::result_of::make_expr<
2885
10980
    boost::proto::tag::function,
2936
11031
{
2937
11032
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan_(), boost::ref(x));
2938
11033
}
 
11034
template<class T, class M>
 
11035
typename boost::proto::result_of::make_expr<
 
11036
    boost::proto::tag::function,
 
11037
    field_domain,
 
11038
    const field_detail::atan_,
 
11039
    const field_component<T,M>&
 
11040
  >::type
 
11041
atan (const field_component<T,M>& x)
 
11042
{
 
11043
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan_(), boost::ref(x));
 
11044
}
 
11045
template<class T, class M>
 
11046
typename boost::proto::result_of::make_expr<
 
11047
    boost::proto::tag::function,
 
11048
    field_domain,
 
11049
    const field_detail::atan_,
 
11050
    const field_component_const<T,M>&
 
11051
  >::type
 
11052
atan (const field_component_const<T,M>& x)
 
11053
{
 
11054
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan_(), boost::ref(x));
 
11055
}
2939
11056
template<class Expr>
2940
11057
typename boost::proto::result_of::make_expr<
2941
11058
    boost::proto::tag::function,
2992
11109
{
2993
11110
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::cosh_(), boost::ref(x));
2994
11111
}
 
11112
template<class T, class M>
 
11113
typename boost::proto::result_of::make_expr<
 
11114
    boost::proto::tag::function,
 
11115
    field_domain,
 
11116
    const field_detail::cosh_,
 
11117
    const field_component<T,M>&
 
11118
  >::type
 
11119
cosh (const field_component<T,M>& x)
 
11120
{
 
11121
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::cosh_(), boost::ref(x));
 
11122
}
 
11123
template<class T, class M>
 
11124
typename boost::proto::result_of::make_expr<
 
11125
    boost::proto::tag::function,
 
11126
    field_domain,
 
11127
    const field_detail::cosh_,
 
11128
    const field_component_const<T,M>&
 
11129
  >::type
 
11130
cosh (const field_component_const<T,M>& x)
 
11131
{
 
11132
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::cosh_(), boost::ref(x));
 
11133
}
2995
11134
template<class Expr>
2996
11135
typename boost::proto::result_of::make_expr<
2997
11136
    boost::proto::tag::function,
3048
11187
{
3049
11188
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::sinh_(), boost::ref(x));
3050
11189
}
 
11190
template<class T, class M>
 
11191
typename boost::proto::result_of::make_expr<
 
11192
    boost::proto::tag::function,
 
11193
    field_domain,
 
11194
    const field_detail::sinh_,
 
11195
    const field_component<T,M>&
 
11196
  >::type
 
11197
sinh (const field_component<T,M>& x)
 
11198
{
 
11199
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::sinh_(), boost::ref(x));
 
11200
}
 
11201
template<class T, class M>
 
11202
typename boost::proto::result_of::make_expr<
 
11203
    boost::proto::tag::function,
 
11204
    field_domain,
 
11205
    const field_detail::sinh_,
 
11206
    const field_component_const<T,M>&
 
11207
  >::type
 
11208
sinh (const field_component_const<T,M>& x)
 
11209
{
 
11210
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::sinh_(), boost::ref(x));
 
11211
}
3051
11212
template<class Expr>
3052
11213
typename boost::proto::result_of::make_expr<
3053
11214
    boost::proto::tag::function,
3104
11265
{
3105
11266
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::tanh_(), boost::ref(x));
3106
11267
}
 
11268
template<class T, class M>
 
11269
typename boost::proto::result_of::make_expr<
 
11270
    boost::proto::tag::function,
 
11271
    field_domain,
 
11272
    const field_detail::tanh_,
 
11273
    const field_component<T,M>&
 
11274
  >::type
 
11275
tanh (const field_component<T,M>& x)
 
11276
{
 
11277
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::tanh_(), boost::ref(x));
 
11278
}
 
11279
template<class T, class M>
 
11280
typename boost::proto::result_of::make_expr<
 
11281
    boost::proto::tag::function,
 
11282
    field_domain,
 
11283
    const field_detail::tanh_,
 
11284
    const field_component_const<T,M>&
 
11285
  >::type
 
11286
tanh (const field_component_const<T,M>& x)
 
11287
{
 
11288
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::tanh_(), boost::ref(x));
 
11289
}
3107
11290
template<class Expr>
3108
11291
typename boost::proto::result_of::make_expr<
3109
11292
    boost::proto::tag::function,
3160
11343
{
3161
11344
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::exp_(), boost::ref(x));
3162
11345
}
 
11346
template<class T, class M>
 
11347
typename boost::proto::result_of::make_expr<
 
11348
    boost::proto::tag::function,
 
11349
    field_domain,
 
11350
    const field_detail::exp_,
 
11351
    const field_component<T,M>&
 
11352
  >::type
 
11353
exp (const field_component<T,M>& x)
 
11354
{
 
11355
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::exp_(), boost::ref(x));
 
11356
}
 
11357
template<class T, class M>
 
11358
typename boost::proto::result_of::make_expr<
 
11359
    boost::proto::tag::function,
 
11360
    field_domain,
 
11361
    const field_detail::exp_,
 
11362
    const field_component_const<T,M>&
 
11363
  >::type
 
11364
exp (const field_component_const<T,M>& x)
 
11365
{
 
11366
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::exp_(), boost::ref(x));
 
11367
}
3163
11368
template<class Expr>
3164
11369
typename boost::proto::result_of::make_expr<
3165
11370
    boost::proto::tag::function,
3216
11421
{
3217
11422
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::log_(), boost::ref(x));
3218
11423
}
 
11424
template<class T, class M>
 
11425
typename boost::proto::result_of::make_expr<
 
11426
    boost::proto::tag::function,
 
11427
    field_domain,
 
11428
    const field_detail::log_,
 
11429
    const field_component<T,M>&
 
11430
  >::type
 
11431
log (const field_component<T,M>& x)
 
11432
{
 
11433
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::log_(), boost::ref(x));
 
11434
}
 
11435
template<class T, class M>
 
11436
typename boost::proto::result_of::make_expr<
 
11437
    boost::proto::tag::function,
 
11438
    field_domain,
 
11439
    const field_detail::log_,
 
11440
    const field_component_const<T,M>&
 
11441
  >::type
 
11442
log (const field_component_const<T,M>& x)
 
11443
{
 
11444
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::log_(), boost::ref(x));
 
11445
}
3219
11446
template<class Expr>
3220
11447
typename boost::proto::result_of::make_expr<
3221
11448
    boost::proto::tag::function,
3272
11499
{
3273
11500
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::log10_(), boost::ref(x));
3274
11501
}
 
11502
template<class T, class M>
 
11503
typename boost::proto::result_of::make_expr<
 
11504
    boost::proto::tag::function,
 
11505
    field_domain,
 
11506
    const field_detail::log10_,
 
11507
    const field_component<T,M>&
 
11508
  >::type
 
11509
log10 (const field_component<T,M>& x)
 
11510
{
 
11511
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::log10_(), boost::ref(x));
 
11512
}
 
11513
template<class T, class M>
 
11514
typename boost::proto::result_of::make_expr<
 
11515
    boost::proto::tag::function,
 
11516
    field_domain,
 
11517
    const field_detail::log10_,
 
11518
    const field_component_const<T,M>&
 
11519
  >::type
 
11520
log10 (const field_component_const<T,M>& x)
 
11521
{
 
11522
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::log10_(), boost::ref(x));
 
11523
}
3275
11524
template<class Expr>
3276
11525
typename boost::proto::result_of::make_expr<
3277
11526
    boost::proto::tag::function,
3328
11577
{
3329
11578
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::sqrt_(), boost::ref(x));
3330
11579
}
 
11580
template<class T, class M>
 
11581
typename boost::proto::result_of::make_expr<
 
11582
    boost::proto::tag::function,
 
11583
    field_domain,
 
11584
    const field_detail::sqrt_,
 
11585
    const field_component<T,M>&
 
11586
  >::type
 
11587
sqrt (const field_component<T,M>& x)
 
11588
{
 
11589
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::sqrt_(), boost::ref(x));
 
11590
}
 
11591
template<class T, class M>
 
11592
typename boost::proto::result_of::make_expr<
 
11593
    boost::proto::tag::function,
 
11594
    field_domain,
 
11595
    const field_detail::sqrt_,
 
11596
    const field_component_const<T,M>&
 
11597
  >::type
 
11598
sqrt (const field_component_const<T,M>& x)
 
11599
{
 
11600
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::sqrt_(), boost::ref(x));
 
11601
}
3331
11602
template<class Expr>
3332
11603
typename boost::proto::result_of::make_expr<
3333
11604
    boost::proto::tag::function,
3384
11655
{
3385
11656
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::abs_(), boost::ref(x));
3386
11657
}
 
11658
template<class T, class M>
 
11659
typename boost::proto::result_of::make_expr<
 
11660
    boost::proto::tag::function,
 
11661
    field_domain,
 
11662
    const field_detail::abs_,
 
11663
    const field_component<T,M>&
 
11664
  >::type
 
11665
abs (const field_component<T,M>& x)
 
11666
{
 
11667
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::abs_(), boost::ref(x));
 
11668
}
 
11669
template<class T, class M>
 
11670
typename boost::proto::result_of::make_expr<
 
11671
    boost::proto::tag::function,
 
11672
    field_domain,
 
11673
    const field_detail::abs_,
 
11674
    const field_component_const<T,M>&
 
11675
  >::type
 
11676
abs (const field_component_const<T,M>& x)
 
11677
{
 
11678
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::abs_(), boost::ref(x));
 
11679
}
3387
11680
template<class Expr>
3388
11681
typename boost::proto::result_of::make_expr<
3389
11682
    boost::proto::tag::function,
3440
11733
{
3441
11734
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fabs_(), boost::ref(x));
3442
11735
}
 
11736
template<class T, class M>
 
11737
typename boost::proto::result_of::make_expr<
 
11738
    boost::proto::tag::function,
 
11739
    field_domain,
 
11740
    const field_detail::fabs_,
 
11741
    const field_component<T,M>&
 
11742
  >::type
 
11743
fabs (const field_component<T,M>& x)
 
11744
{
 
11745
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fabs_(), boost::ref(x));
 
11746
}
 
11747
template<class T, class M>
 
11748
typename boost::proto::result_of::make_expr<
 
11749
    boost::proto::tag::function,
 
11750
    field_domain,
 
11751
    const field_detail::fabs_,
 
11752
    const field_component_const<T,M>&
 
11753
  >::type
 
11754
fabs (const field_component_const<T,M>& x)
 
11755
{
 
11756
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fabs_(), boost::ref(x));
 
11757
}
3443
11758
template<class Expr>
3444
11759
typename boost::proto::result_of::make_expr<
3445
11760
    boost::proto::tag::function,
3496
11811
{
3497
11812
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::floor_(), boost::ref(x));
3498
11813
}
 
11814
template<class T, class M>
 
11815
typename boost::proto::result_of::make_expr<
 
11816
    boost::proto::tag::function,
 
11817
    field_domain,
 
11818
    const field_detail::floor_,
 
11819
    const field_component<T,M>&
 
11820
  >::type
 
11821
floor (const field_component<T,M>& x)
 
11822
{
 
11823
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::floor_(), boost::ref(x));
 
11824
}
 
11825
template<class T, class M>
 
11826
typename boost::proto::result_of::make_expr<
 
11827
    boost::proto::tag::function,
 
11828
    field_domain,
 
11829
    const field_detail::floor_,
 
11830
    const field_component_const<T,M>&
 
11831
  >::type
 
11832
floor (const field_component_const<T,M>& x)
 
11833
{
 
11834
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::floor_(), boost::ref(x));
 
11835
}
3499
11836
template<class Expr>
3500
11837
typename boost::proto::result_of::make_expr<
3501
11838
    boost::proto::tag::function,
3552
11889
{
3553
11890
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::ceil_(), boost::ref(x));
3554
11891
}
 
11892
template<class T, class M>
 
11893
typename boost::proto::result_of::make_expr<
 
11894
    boost::proto::tag::function,
 
11895
    field_domain,
 
11896
    const field_detail::ceil_,
 
11897
    const field_component<T,M>&
 
11898
  >::type
 
11899
ceil (const field_component<T,M>& x)
 
11900
{
 
11901
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::ceil_(), boost::ref(x));
 
11902
}
 
11903
template<class T, class M>
 
11904
typename boost::proto::result_of::make_expr<
 
11905
    boost::proto::tag::function,
 
11906
    field_domain,
 
11907
    const field_detail::ceil_,
 
11908
    const field_component_const<T,M>&
 
11909
  >::type
 
11910
ceil (const field_component_const<T,M>& x)
 
11911
{
 
11912
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::ceil_(), boost::ref(x));
 
11913
}
3555
11914
template<class Expr>
3556
11915
typename boost::proto::result_of::make_expr<
3557
11916
    boost::proto::tag::function,
3608
11967
{
3609
11968
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::sqr_(), boost::ref(x));
3610
11969
}
 
11970
template<class T, class M>
 
11971
typename boost::proto::result_of::make_expr<
 
11972
    boost::proto::tag::function,
 
11973
    field_domain,
 
11974
    const field_detail::sqr_,
 
11975
    const field_component<T,M>&
 
11976
  >::type
 
11977
sqr (const field_component<T,M>& x)
 
11978
{
 
11979
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::sqr_(), boost::ref(x));
 
11980
}
 
11981
template<class T, class M>
 
11982
typename boost::proto::result_of::make_expr<
 
11983
    boost::proto::tag::function,
 
11984
    field_domain,
 
11985
    const field_detail::sqr_,
 
11986
    const field_component_const<T,M>&
 
11987
  >::type
 
11988
sqr (const field_component_const<T,M>& x)
 
11989
{
 
11990
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::sqr_(), boost::ref(x));
 
11991
}
3611
11992
template<class Expr>
3612
11993
typename boost::proto::result_of::make_expr<
3613
11994
    boost::proto::tag::function,
3715
12096
    boost::proto::tag::function,
3716
12097
    field_domain,
3717
12098
    const field_detail::atan2_,
 
12099
    const int&,
 
12100
    const field_component<T,M>&
 
12101
  >::type
 
12102
atan2 (const int& x, const field_component<T,M>& y)
 
12103
{
 
12104
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
 
12105
}
 
12106
template<class T1, class T2, class M>
 
12107
typename boost::proto::result_of::make_expr<
 
12108
    boost::proto::tag::function,
 
12109
    field_domain,
 
12110
    const field_detail::atan2_,
 
12111
    const T1&,
 
12112
    const field_component<T2,M>&
 
12113
  >::type
 
12114
atan2 (const T1& x, const field_component<T2,M>& y)
 
12115
{
 
12116
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
 
12117
}
 
12118
template<class T, class M>
 
12119
typename boost::proto::result_of::make_expr<
 
12120
    boost::proto::tag::function,
 
12121
    field_domain,
 
12122
    const field_detail::atan2_,
 
12123
    const int&,
 
12124
    const field_component_const<T,M>&
 
12125
  >::type
 
12126
atan2 (const int& x, const field_component_const<T,M>& y)
 
12127
{
 
12128
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
 
12129
}
 
12130
template<class T1, class T2, class M>
 
12131
typename boost::proto::result_of::make_expr<
 
12132
    boost::proto::tag::function,
 
12133
    field_domain,
 
12134
    const field_detail::atan2_,
 
12135
    const T1&,
 
12136
    const field_component_const<T2,M>&
 
12137
  >::type
 
12138
atan2 (const T1& x, const field_component_const<T2,M>& y)
 
12139
{
 
12140
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
 
12141
}
 
12142
template<class T, class M>
 
12143
typename boost::proto::result_of::make_expr<
 
12144
    boost::proto::tag::function,
 
12145
    field_domain,
 
12146
    const field_detail::atan2_,
3718
12147
    const field_basic<T,M>&,
3719
12148
    const int&
3720
12149
  >::type
3782
12211
{
3783
12212
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
3784
12213
}
 
12214
template<class T, class M>
 
12215
typename boost::proto::result_of::make_expr<
 
12216
    boost::proto::tag::function,
 
12217
    field_domain,
 
12218
    const field_detail::atan2_,
 
12219
    const field_component<T,M>&,
 
12220
    const int&
 
12221
  >::type
 
12222
atan2 (const field_component<T,M>& x, const int& y)
 
12223
{
 
12224
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
 
12225
}
 
12226
template<class T1, class T2, class M>
 
12227
typename boost::proto::result_of::make_expr<
 
12228
    boost::proto::tag::function,
 
12229
    field_domain,
 
12230
    const field_detail::atan2_,
 
12231
    const field_component<T1,M>&,
 
12232
    const T2&
 
12233
  >::type
 
12234
atan2 (const field_component<T1,M>& x, const T2& y)
 
12235
{
 
12236
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
 
12237
}
 
12238
template<class T, class M>
 
12239
typename boost::proto::result_of::make_expr<
 
12240
    boost::proto::tag::function,
 
12241
    field_domain,
 
12242
    const field_detail::atan2_,
 
12243
    const field_component_const<T,M>&,
 
12244
    const int&
 
12245
  >::type
 
12246
atan2 (const field_component_const<T,M>& x, const int& y)
 
12247
{
 
12248
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
 
12249
}
 
12250
template<class T1, class T2, class M>
 
12251
typename boost::proto::result_of::make_expr<
 
12252
    boost::proto::tag::function,
 
12253
    field_domain,
 
12254
    const field_detail::atan2_,
 
12255
    const field_component_const<T1,M>&,
 
12256
    const T2&
 
12257
  >::type
 
12258
atan2 (const field_component_const<T1,M>& x, const T2& y)
 
12259
{
 
12260
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
 
12261
}
3785
12262
template<class T1, class T2, class M>
3786
12263
typename boost::proto::result_of::make_expr<
3787
12264
    boost::proto::tag::function,
3823
12300
    boost::proto::tag::function,
3824
12301
    field_domain,
3825
12302
    const field_detail::atan2_,
 
12303
    const field_basic<T1,M>&,
 
12304
    const field_component<T2,M>&
 
12305
  >::type
 
12306
atan2 (const field_basic<T1,M>& x, const field_component<T2,M>& y)
 
12307
{
 
12308
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
 
12309
}
 
12310
template<class T1, class T2, class M>
 
12311
typename boost::proto::result_of::make_expr<
 
12312
    boost::proto::tag::function,
 
12313
    field_domain,
 
12314
    const field_detail::atan2_,
 
12315
    const field_basic<T1,M>&,
 
12316
    const field_component_const<T2,M>&
 
12317
  >::type
 
12318
atan2 (const field_basic<T1,M>& x, const field_component_const<T2,M>& y)
 
12319
{
 
12320
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
 
12321
}
 
12322
template<class T1, class T2, class M>
 
12323
typename boost::proto::result_of::make_expr<
 
12324
    boost::proto::tag::function,
 
12325
    field_domain,
 
12326
    const field_detail::atan2_,
3826
12327
    const field_indirect<T1,M>&,
3827
12328
    const field_basic<T2,M>&
3828
12329
  >::type
3859
12360
    boost::proto::tag::function,
3860
12361
    field_domain,
3861
12362
    const field_detail::atan2_,
 
12363
    const field_indirect<T1,M>&,
 
12364
    const field_component<T2,M>&
 
12365
  >::type
 
12366
atan2 (const field_indirect<T1,M>& x, const field_component<T2,M>& y)
 
12367
{
 
12368
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
 
12369
}
 
12370
template<class T1, class T2, class M>
 
12371
typename boost::proto::result_of::make_expr<
 
12372
    boost::proto::tag::function,
 
12373
    field_domain,
 
12374
    const field_detail::atan2_,
 
12375
    const field_indirect<T1,M>&,
 
12376
    const field_component_const<T2,M>&
 
12377
  >::type
 
12378
atan2 (const field_indirect<T1,M>& x, const field_component_const<T2,M>& y)
 
12379
{
 
12380
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
 
12381
}
 
12382
template<class T1, class T2, class M>
 
12383
typename boost::proto::result_of::make_expr<
 
12384
    boost::proto::tag::function,
 
12385
    field_domain,
 
12386
    const field_detail::atan2_,
3862
12387
    const field_indirect_const<T1,M>&,
3863
12388
    const field_basic<T2,M>&
3864
12389
  >::type
3890
12415
{
3891
12416
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
3892
12417
}
 
12418
template<class T1, class T2, class M>
 
12419
typename boost::proto::result_of::make_expr<
 
12420
    boost::proto::tag::function,
 
12421
    field_domain,
 
12422
    const field_detail::atan2_,
 
12423
    const field_indirect_const<T1,M>&,
 
12424
    const field_component<T2,M>&
 
12425
  >::type
 
12426
atan2 (const field_indirect_const<T1,M>& x, const field_component<T2,M>& y)
 
12427
{
 
12428
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
 
12429
}
 
12430
template<class T1, class T2, class M>
 
12431
typename boost::proto::result_of::make_expr<
 
12432
    boost::proto::tag::function,
 
12433
    field_domain,
 
12434
    const field_detail::atan2_,
 
12435
    const field_indirect_const<T1,M>&,
 
12436
    const field_component_const<T2,M>&
 
12437
  >::type
 
12438
atan2 (const field_indirect_const<T1,M>& x, const field_component_const<T2,M>& y)
 
12439
{
 
12440
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
 
12441
}
 
12442
template<class T1, class T2, class M>
 
12443
typename boost::proto::result_of::make_expr<
 
12444
    boost::proto::tag::function,
 
12445
    field_domain,
 
12446
    const field_detail::atan2_,
 
12447
    const field_component<T1,M>&,
 
12448
    const field_basic<T2,M>&
 
12449
  >::type
 
12450
atan2 (const field_component<T1,M>& x, const field_basic<T2,M>& y)
 
12451
{
 
12452
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
 
12453
}
 
12454
template<class T1, class T2, class M>
 
12455
typename boost::proto::result_of::make_expr<
 
12456
    boost::proto::tag::function,
 
12457
    field_domain,
 
12458
    const field_detail::atan2_,
 
12459
    const field_component<T1,M>&,
 
12460
    const field_indirect<T2,M>&
 
12461
  >::type
 
12462
atan2 (const field_component<T1,M>& x, const field_indirect<T2,M>& y)
 
12463
{
 
12464
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
 
12465
}
 
12466
template<class T1, class T2, class M>
 
12467
typename boost::proto::result_of::make_expr<
 
12468
    boost::proto::tag::function,
 
12469
    field_domain,
 
12470
    const field_detail::atan2_,
 
12471
    const field_component<T1,M>&,
 
12472
    const field_indirect_const<T2,M>&
 
12473
  >::type
 
12474
atan2 (const field_component<T1,M>& x, const field_indirect_const<T2,M>& y)
 
12475
{
 
12476
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
 
12477
}
 
12478
template<class T1, class T2, class M>
 
12479
typename boost::proto::result_of::make_expr<
 
12480
    boost::proto::tag::function,
 
12481
    field_domain,
 
12482
    const field_detail::atan2_,
 
12483
    const field_component<T1,M>&,
 
12484
    const field_component<T2,M>&
 
12485
  >::type
 
12486
atan2 (const field_component<T1,M>& x, const field_component<T2,M>& y)
 
12487
{
 
12488
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
 
12489
}
 
12490
template<class T1, class T2, class M>
 
12491
typename boost::proto::result_of::make_expr<
 
12492
    boost::proto::tag::function,
 
12493
    field_domain,
 
12494
    const field_detail::atan2_,
 
12495
    const field_component<T1,M>&,
 
12496
    const field_component_const<T2,M>&
 
12497
  >::type
 
12498
atan2 (const field_component<T1,M>& x, const field_component_const<T2,M>& y)
 
12499
{
 
12500
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
 
12501
}
 
12502
template<class T1, class T2, class M>
 
12503
typename boost::proto::result_of::make_expr<
 
12504
    boost::proto::tag::function,
 
12505
    field_domain,
 
12506
    const field_detail::atan2_,
 
12507
    const field_component_const<T1,M>&,
 
12508
    const field_basic<T2,M>&
 
12509
  >::type
 
12510
atan2 (const field_component_const<T1,M>& x, const field_basic<T2,M>& y)
 
12511
{
 
12512
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
 
12513
}
 
12514
template<class T1, class T2, class M>
 
12515
typename boost::proto::result_of::make_expr<
 
12516
    boost::proto::tag::function,
 
12517
    field_domain,
 
12518
    const field_detail::atan2_,
 
12519
    const field_component_const<T1,M>&,
 
12520
    const field_indirect<T2,M>&
 
12521
  >::type
 
12522
atan2 (const field_component_const<T1,M>& x, const field_indirect<T2,M>& y)
 
12523
{
 
12524
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
 
12525
}
 
12526
template<class T1, class T2, class M>
 
12527
typename boost::proto::result_of::make_expr<
 
12528
    boost::proto::tag::function,
 
12529
    field_domain,
 
12530
    const field_detail::atan2_,
 
12531
    const field_component_const<T1,M>&,
 
12532
    const field_indirect_const<T2,M>&
 
12533
  >::type
 
12534
atan2 (const field_component_const<T1,M>& x, const field_indirect_const<T2,M>& y)
 
12535
{
 
12536
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
 
12537
}
 
12538
template<class T1, class T2, class M>
 
12539
typename boost::proto::result_of::make_expr<
 
12540
    boost::proto::tag::function,
 
12541
    field_domain,
 
12542
    const field_detail::atan2_,
 
12543
    const field_component_const<T1,M>&,
 
12544
    const field_component<T2,M>&
 
12545
  >::type
 
12546
atan2 (const field_component_const<T1,M>& x, const field_component<T2,M>& y)
 
12547
{
 
12548
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
 
12549
}
 
12550
template<class T1, class T2, class M>
 
12551
typename boost::proto::result_of::make_expr<
 
12552
    boost::proto::tag::function,
 
12553
    field_domain,
 
12554
    const field_detail::atan2_,
 
12555
    const field_component_const<T1,M>&,
 
12556
    const field_component_const<T2,M>&
 
12557
  >::type
 
12558
atan2 (const field_component_const<T1,M>& x, const field_component_const<T2,M>& y)
 
12559
{
 
12560
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
 
12561
}
3893
12562
template<class Expr>
3894
12563
typename boost::proto::result_of::make_expr<
3895
12564
    boost::proto::tag::function,
4010
12679
{
4011
12680
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
4012
12681
}
 
12682
template<class T, class M, class Expr>
 
12683
typename boost::proto::result_of::make_expr<
 
12684
    boost::proto::tag::function,
 
12685
    field_domain,
 
12686
    const field_detail::atan2_,
 
12687
    const field_component<T,M>&,
 
12688
    const field_expr<Expr>&
 
12689
  >::type
 
12690
atan2 (const field_component<T,M>& x, const field_expr<Expr>& y)
 
12691
{
 
12692
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
 
12693
}
 
12694
template<class T, class M, class Expr>
 
12695
typename boost::proto::result_of::make_expr<
 
12696
    boost::proto::tag::function,
 
12697
    field_domain,
 
12698
    const field_detail::atan2_,
 
12699
    const field_expr<Expr>&,
 
12700
    const field_component<T,M>&
 
12701
  >::type
 
12702
atan2 (const field_expr<Expr>& x, const field_component<T,M>& y)
 
12703
{
 
12704
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
 
12705
}
 
12706
template<class T, class M, class Expr>
 
12707
typename boost::proto::result_of::make_expr<
 
12708
    boost::proto::tag::function,
 
12709
    field_domain,
 
12710
    const field_detail::atan2_,
 
12711
    const field_component_const<T,M>&,
 
12712
    const field_expr<Expr>&
 
12713
  >::type
 
12714
atan2 (const field_component_const<T,M>& x, const field_expr<Expr>& y)
 
12715
{
 
12716
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
 
12717
}
 
12718
template<class T, class M, class Expr>
 
12719
typename boost::proto::result_of::make_expr<
 
12720
    boost::proto::tag::function,
 
12721
    field_domain,
 
12722
    const field_detail::atan2_,
 
12723
    const field_expr<Expr>&,
 
12724
    const field_component_const<T,M>&
 
12725
  >::type
 
12726
atan2 (const field_expr<Expr>& x, const field_component_const<T,M>& y)
 
12727
{
 
12728
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::atan2_(), boost::ref(x), boost::ref(y));
 
12729
}
4013
12730
template<class Expr1, class Expr2>
4014
12731
typename boost::proto::result_of::make_expr<
4015
12732
    boost::proto::tag::function,
4118
12835
    boost::proto::tag::function,
4119
12836
    field_domain,
4120
12837
    const field_detail::pow_,
 
12838
    const int&,
 
12839
    const field_component<T,M>&
 
12840
  >::type
 
12841
pow (const int& x, const field_component<T,M>& y)
 
12842
{
 
12843
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
 
12844
}
 
12845
template<class T1, class T2, class M>
 
12846
typename boost::proto::result_of::make_expr<
 
12847
    boost::proto::tag::function,
 
12848
    field_domain,
 
12849
    const field_detail::pow_,
 
12850
    const T1&,
 
12851
    const field_component<T2,M>&
 
12852
  >::type
 
12853
pow (const T1& x, const field_component<T2,M>& y)
 
12854
{
 
12855
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
 
12856
}
 
12857
template<class T, class M>
 
12858
typename boost::proto::result_of::make_expr<
 
12859
    boost::proto::tag::function,
 
12860
    field_domain,
 
12861
    const field_detail::pow_,
 
12862
    const int&,
 
12863
    const field_component_const<T,M>&
 
12864
  >::type
 
12865
pow (const int& x, const field_component_const<T,M>& y)
 
12866
{
 
12867
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
 
12868
}
 
12869
template<class T1, class T2, class M>
 
12870
typename boost::proto::result_of::make_expr<
 
12871
    boost::proto::tag::function,
 
12872
    field_domain,
 
12873
    const field_detail::pow_,
 
12874
    const T1&,
 
12875
    const field_component_const<T2,M>&
 
12876
  >::type
 
12877
pow (const T1& x, const field_component_const<T2,M>& y)
 
12878
{
 
12879
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
 
12880
}
 
12881
template<class T, class M>
 
12882
typename boost::proto::result_of::make_expr<
 
12883
    boost::proto::tag::function,
 
12884
    field_domain,
 
12885
    const field_detail::pow_,
4121
12886
    const field_basic<T,M>&,
4122
12887
    const int&
4123
12888
  >::type
4185
12950
{
4186
12951
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
4187
12952
}
 
12953
template<class T, class M>
 
12954
typename boost::proto::result_of::make_expr<
 
12955
    boost::proto::tag::function,
 
12956
    field_domain,
 
12957
    const field_detail::pow_,
 
12958
    const field_component<T,M>&,
 
12959
    const int&
 
12960
  >::type
 
12961
pow (const field_component<T,M>& x, const int& y)
 
12962
{
 
12963
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
 
12964
}
 
12965
template<class T1, class T2, class M>
 
12966
typename boost::proto::result_of::make_expr<
 
12967
    boost::proto::tag::function,
 
12968
    field_domain,
 
12969
    const field_detail::pow_,
 
12970
    const field_component<T1,M>&,
 
12971
    const T2&
 
12972
  >::type
 
12973
pow (const field_component<T1,M>& x, const T2& y)
 
12974
{
 
12975
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
 
12976
}
 
12977
template<class T, class M>
 
12978
typename boost::proto::result_of::make_expr<
 
12979
    boost::proto::tag::function,
 
12980
    field_domain,
 
12981
    const field_detail::pow_,
 
12982
    const field_component_const<T,M>&,
 
12983
    const int&
 
12984
  >::type
 
12985
pow (const field_component_const<T,M>& x, const int& y)
 
12986
{
 
12987
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
 
12988
}
 
12989
template<class T1, class T2, class M>
 
12990
typename boost::proto::result_of::make_expr<
 
12991
    boost::proto::tag::function,
 
12992
    field_domain,
 
12993
    const field_detail::pow_,
 
12994
    const field_component_const<T1,M>&,
 
12995
    const T2&
 
12996
  >::type
 
12997
pow (const field_component_const<T1,M>& x, const T2& y)
 
12998
{
 
12999
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
 
13000
}
4188
13001
template<class T1, class T2, class M>
4189
13002
typename boost::proto::result_of::make_expr<
4190
13003
    boost::proto::tag::function,
4226
13039
    boost::proto::tag::function,
4227
13040
    field_domain,
4228
13041
    const field_detail::pow_,
 
13042
    const field_basic<T1,M>&,
 
13043
    const field_component<T2,M>&
 
13044
  >::type
 
13045
pow (const field_basic<T1,M>& x, const field_component<T2,M>& y)
 
13046
{
 
13047
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
 
13048
}
 
13049
template<class T1, class T2, class M>
 
13050
typename boost::proto::result_of::make_expr<
 
13051
    boost::proto::tag::function,
 
13052
    field_domain,
 
13053
    const field_detail::pow_,
 
13054
    const field_basic<T1,M>&,
 
13055
    const field_component_const<T2,M>&
 
13056
  >::type
 
13057
pow (const field_basic<T1,M>& x, const field_component_const<T2,M>& y)
 
13058
{
 
13059
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
 
13060
}
 
13061
template<class T1, class T2, class M>
 
13062
typename boost::proto::result_of::make_expr<
 
13063
    boost::proto::tag::function,
 
13064
    field_domain,
 
13065
    const field_detail::pow_,
4229
13066
    const field_indirect<T1,M>&,
4230
13067
    const field_basic<T2,M>&
4231
13068
  >::type
4262
13099
    boost::proto::tag::function,
4263
13100
    field_domain,
4264
13101
    const field_detail::pow_,
 
13102
    const field_indirect<T1,M>&,
 
13103
    const field_component<T2,M>&
 
13104
  >::type
 
13105
pow (const field_indirect<T1,M>& x, const field_component<T2,M>& y)
 
13106
{
 
13107
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
 
13108
}
 
13109
template<class T1, class T2, class M>
 
13110
typename boost::proto::result_of::make_expr<
 
13111
    boost::proto::tag::function,
 
13112
    field_domain,
 
13113
    const field_detail::pow_,
 
13114
    const field_indirect<T1,M>&,
 
13115
    const field_component_const<T2,M>&
 
13116
  >::type
 
13117
pow (const field_indirect<T1,M>& x, const field_component_const<T2,M>& y)
 
13118
{
 
13119
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
 
13120
}
 
13121
template<class T1, class T2, class M>
 
13122
typename boost::proto::result_of::make_expr<
 
13123
    boost::proto::tag::function,
 
13124
    field_domain,
 
13125
    const field_detail::pow_,
4265
13126
    const field_indirect_const<T1,M>&,
4266
13127
    const field_basic<T2,M>&
4267
13128
  >::type
4293
13154
{
4294
13155
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
4295
13156
}
 
13157
template<class T1, class T2, class M>
 
13158
typename boost::proto::result_of::make_expr<
 
13159
    boost::proto::tag::function,
 
13160
    field_domain,
 
13161
    const field_detail::pow_,
 
13162
    const field_indirect_const<T1,M>&,
 
13163
    const field_component<T2,M>&
 
13164
  >::type
 
13165
pow (const field_indirect_const<T1,M>& x, const field_component<T2,M>& y)
 
13166
{
 
13167
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
 
13168
}
 
13169
template<class T1, class T2, class M>
 
13170
typename boost::proto::result_of::make_expr<
 
13171
    boost::proto::tag::function,
 
13172
    field_domain,
 
13173
    const field_detail::pow_,
 
13174
    const field_indirect_const<T1,M>&,
 
13175
    const field_component_const<T2,M>&
 
13176
  >::type
 
13177
pow (const field_indirect_const<T1,M>& x, const field_component_const<T2,M>& y)
 
13178
{
 
13179
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
 
13180
}
 
13181
template<class T1, class T2, class M>
 
13182
typename boost::proto::result_of::make_expr<
 
13183
    boost::proto::tag::function,
 
13184
    field_domain,
 
13185
    const field_detail::pow_,
 
13186
    const field_component<T1,M>&,
 
13187
    const field_basic<T2,M>&
 
13188
  >::type
 
13189
pow (const field_component<T1,M>& x, const field_basic<T2,M>& y)
 
13190
{
 
13191
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
 
13192
}
 
13193
template<class T1, class T2, class M>
 
13194
typename boost::proto::result_of::make_expr<
 
13195
    boost::proto::tag::function,
 
13196
    field_domain,
 
13197
    const field_detail::pow_,
 
13198
    const field_component<T1,M>&,
 
13199
    const field_indirect<T2,M>&
 
13200
  >::type
 
13201
pow (const field_component<T1,M>& x, const field_indirect<T2,M>& y)
 
13202
{
 
13203
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
 
13204
}
 
13205
template<class T1, class T2, class M>
 
13206
typename boost::proto::result_of::make_expr<
 
13207
    boost::proto::tag::function,
 
13208
    field_domain,
 
13209
    const field_detail::pow_,
 
13210
    const field_component<T1,M>&,
 
13211
    const field_indirect_const<T2,M>&
 
13212
  >::type
 
13213
pow (const field_component<T1,M>& x, const field_indirect_const<T2,M>& y)
 
13214
{
 
13215
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
 
13216
}
 
13217
template<class T1, class T2, class M>
 
13218
typename boost::proto::result_of::make_expr<
 
13219
    boost::proto::tag::function,
 
13220
    field_domain,
 
13221
    const field_detail::pow_,
 
13222
    const field_component<T1,M>&,
 
13223
    const field_component<T2,M>&
 
13224
  >::type
 
13225
pow (const field_component<T1,M>& x, const field_component<T2,M>& y)
 
13226
{
 
13227
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
 
13228
}
 
13229
template<class T1, class T2, class M>
 
13230
typename boost::proto::result_of::make_expr<
 
13231
    boost::proto::tag::function,
 
13232
    field_domain,
 
13233
    const field_detail::pow_,
 
13234
    const field_component<T1,M>&,
 
13235
    const field_component_const<T2,M>&
 
13236
  >::type
 
13237
pow (const field_component<T1,M>& x, const field_component_const<T2,M>& y)
 
13238
{
 
13239
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
 
13240
}
 
13241
template<class T1, class T2, class M>
 
13242
typename boost::proto::result_of::make_expr<
 
13243
    boost::proto::tag::function,
 
13244
    field_domain,
 
13245
    const field_detail::pow_,
 
13246
    const field_component_const<T1,M>&,
 
13247
    const field_basic<T2,M>&
 
13248
  >::type
 
13249
pow (const field_component_const<T1,M>& x, const field_basic<T2,M>& y)
 
13250
{
 
13251
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
 
13252
}
 
13253
template<class T1, class T2, class M>
 
13254
typename boost::proto::result_of::make_expr<
 
13255
    boost::proto::tag::function,
 
13256
    field_domain,
 
13257
    const field_detail::pow_,
 
13258
    const field_component_const<T1,M>&,
 
13259
    const field_indirect<T2,M>&
 
13260
  >::type
 
13261
pow (const field_component_const<T1,M>& x, const field_indirect<T2,M>& y)
 
13262
{
 
13263
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
 
13264
}
 
13265
template<class T1, class T2, class M>
 
13266
typename boost::proto::result_of::make_expr<
 
13267
    boost::proto::tag::function,
 
13268
    field_domain,
 
13269
    const field_detail::pow_,
 
13270
    const field_component_const<T1,M>&,
 
13271
    const field_indirect_const<T2,M>&
 
13272
  >::type
 
13273
pow (const field_component_const<T1,M>& x, const field_indirect_const<T2,M>& y)
 
13274
{
 
13275
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
 
13276
}
 
13277
template<class T1, class T2, class M>
 
13278
typename boost::proto::result_of::make_expr<
 
13279
    boost::proto::tag::function,
 
13280
    field_domain,
 
13281
    const field_detail::pow_,
 
13282
    const field_component_const<T1,M>&,
 
13283
    const field_component<T2,M>&
 
13284
  >::type
 
13285
pow (const field_component_const<T1,M>& x, const field_component<T2,M>& y)
 
13286
{
 
13287
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
 
13288
}
 
13289
template<class T1, class T2, class M>
 
13290
typename boost::proto::result_of::make_expr<
 
13291
    boost::proto::tag::function,
 
13292
    field_domain,
 
13293
    const field_detail::pow_,
 
13294
    const field_component_const<T1,M>&,
 
13295
    const field_component_const<T2,M>&
 
13296
  >::type
 
13297
pow (const field_component_const<T1,M>& x, const field_component_const<T2,M>& y)
 
13298
{
 
13299
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
 
13300
}
4296
13301
template<class Expr>
4297
13302
typename boost::proto::result_of::make_expr<
4298
13303
    boost::proto::tag::function,
4413
13418
{
4414
13419
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
4415
13420
}
 
13421
template<class T, class M, class Expr>
 
13422
typename boost::proto::result_of::make_expr<
 
13423
    boost::proto::tag::function,
 
13424
    field_domain,
 
13425
    const field_detail::pow_,
 
13426
    const field_component<T,M>&,
 
13427
    const field_expr<Expr>&
 
13428
  >::type
 
13429
pow (const field_component<T,M>& x, const field_expr<Expr>& y)
 
13430
{
 
13431
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
 
13432
}
 
13433
template<class T, class M, class Expr>
 
13434
typename boost::proto::result_of::make_expr<
 
13435
    boost::proto::tag::function,
 
13436
    field_domain,
 
13437
    const field_detail::pow_,
 
13438
    const field_expr<Expr>&,
 
13439
    const field_component<T,M>&
 
13440
  >::type
 
13441
pow (const field_expr<Expr>& x, const field_component<T,M>& y)
 
13442
{
 
13443
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
 
13444
}
 
13445
template<class T, class M, class Expr>
 
13446
typename boost::proto::result_of::make_expr<
 
13447
    boost::proto::tag::function,
 
13448
    field_domain,
 
13449
    const field_detail::pow_,
 
13450
    const field_component_const<T,M>&,
 
13451
    const field_expr<Expr>&
 
13452
  >::type
 
13453
pow (const field_component_const<T,M>& x, const field_expr<Expr>& y)
 
13454
{
 
13455
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
 
13456
}
 
13457
template<class T, class M, class Expr>
 
13458
typename boost::proto::result_of::make_expr<
 
13459
    boost::proto::tag::function,
 
13460
    field_domain,
 
13461
    const field_detail::pow_,
 
13462
    const field_expr<Expr>&,
 
13463
    const field_component_const<T,M>&
 
13464
  >::type
 
13465
pow (const field_expr<Expr>& x, const field_component_const<T,M>& y)
 
13466
{
 
13467
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::pow_(), boost::ref(x), boost::ref(y));
 
13468
}
4416
13469
template<class Expr1, class Expr2>
4417
13470
typename boost::proto::result_of::make_expr<
4418
13471
    boost::proto::tag::function,
4521
13574
    boost::proto::tag::function,
4522
13575
    field_domain,
4523
13576
    const field_detail::fmod_,
 
13577
    const int&,
 
13578
    const field_component<T,M>&
 
13579
  >::type
 
13580
fmod (const int& x, const field_component<T,M>& y)
 
13581
{
 
13582
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
 
13583
}
 
13584
template<class T1, class T2, class M>
 
13585
typename boost::proto::result_of::make_expr<
 
13586
    boost::proto::tag::function,
 
13587
    field_domain,
 
13588
    const field_detail::fmod_,
 
13589
    const T1&,
 
13590
    const field_component<T2,M>&
 
13591
  >::type
 
13592
fmod (const T1& x, const field_component<T2,M>& y)
 
13593
{
 
13594
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
 
13595
}
 
13596
template<class T, class M>
 
13597
typename boost::proto::result_of::make_expr<
 
13598
    boost::proto::tag::function,
 
13599
    field_domain,
 
13600
    const field_detail::fmod_,
 
13601
    const int&,
 
13602
    const field_component_const<T,M>&
 
13603
  >::type
 
13604
fmod (const int& x, const field_component_const<T,M>& y)
 
13605
{
 
13606
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
 
13607
}
 
13608
template<class T1, class T2, class M>
 
13609
typename boost::proto::result_of::make_expr<
 
13610
    boost::proto::tag::function,
 
13611
    field_domain,
 
13612
    const field_detail::fmod_,
 
13613
    const T1&,
 
13614
    const field_component_const<T2,M>&
 
13615
  >::type
 
13616
fmod (const T1& x, const field_component_const<T2,M>& y)
 
13617
{
 
13618
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
 
13619
}
 
13620
template<class T, class M>
 
13621
typename boost::proto::result_of::make_expr<
 
13622
    boost::proto::tag::function,
 
13623
    field_domain,
 
13624
    const field_detail::fmod_,
4524
13625
    const field_basic<T,M>&,
4525
13626
    const int&
4526
13627
  >::type
4588
13689
{
4589
13690
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
4590
13691
}
 
13692
template<class T, class M>
 
13693
typename boost::proto::result_of::make_expr<
 
13694
    boost::proto::tag::function,
 
13695
    field_domain,
 
13696
    const field_detail::fmod_,
 
13697
    const field_component<T,M>&,
 
13698
    const int&
 
13699
  >::type
 
13700
fmod (const field_component<T,M>& x, const int& y)
 
13701
{
 
13702
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
 
13703
}
 
13704
template<class T1, class T2, class M>
 
13705
typename boost::proto::result_of::make_expr<
 
13706
    boost::proto::tag::function,
 
13707
    field_domain,
 
13708
    const field_detail::fmod_,
 
13709
    const field_component<T1,M>&,
 
13710
    const T2&
 
13711
  >::type
 
13712
fmod (const field_component<T1,M>& x, const T2& y)
 
13713
{
 
13714
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
 
13715
}
 
13716
template<class T, class M>
 
13717
typename boost::proto::result_of::make_expr<
 
13718
    boost::proto::tag::function,
 
13719
    field_domain,
 
13720
    const field_detail::fmod_,
 
13721
    const field_component_const<T,M>&,
 
13722
    const int&
 
13723
  >::type
 
13724
fmod (const field_component_const<T,M>& x, const int& y)
 
13725
{
 
13726
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
 
13727
}
 
13728
template<class T1, class T2, class M>
 
13729
typename boost::proto::result_of::make_expr<
 
13730
    boost::proto::tag::function,
 
13731
    field_domain,
 
13732
    const field_detail::fmod_,
 
13733
    const field_component_const<T1,M>&,
 
13734
    const T2&
 
13735
  >::type
 
13736
fmod (const field_component_const<T1,M>& x, const T2& y)
 
13737
{
 
13738
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
 
13739
}
4591
13740
template<class T1, class T2, class M>
4592
13741
typename boost::proto::result_of::make_expr<
4593
13742
    boost::proto::tag::function,
4629
13778
    boost::proto::tag::function,
4630
13779
    field_domain,
4631
13780
    const field_detail::fmod_,
 
13781
    const field_basic<T1,M>&,
 
13782
    const field_component<T2,M>&
 
13783
  >::type
 
13784
fmod (const field_basic<T1,M>& x, const field_component<T2,M>& y)
 
13785
{
 
13786
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
 
13787
}
 
13788
template<class T1, class T2, class M>
 
13789
typename boost::proto::result_of::make_expr<
 
13790
    boost::proto::tag::function,
 
13791
    field_domain,
 
13792
    const field_detail::fmod_,
 
13793
    const field_basic<T1,M>&,
 
13794
    const field_component_const<T2,M>&
 
13795
  >::type
 
13796
fmod (const field_basic<T1,M>& x, const field_component_const<T2,M>& y)
 
13797
{
 
13798
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
 
13799
}
 
13800
template<class T1, class T2, class M>
 
13801
typename boost::proto::result_of::make_expr<
 
13802
    boost::proto::tag::function,
 
13803
    field_domain,
 
13804
    const field_detail::fmod_,
4632
13805
    const field_indirect<T1,M>&,
4633
13806
    const field_basic<T2,M>&
4634
13807
  >::type
4665
13838
    boost::proto::tag::function,
4666
13839
    field_domain,
4667
13840
    const field_detail::fmod_,
 
13841
    const field_indirect<T1,M>&,
 
13842
    const field_component<T2,M>&
 
13843
  >::type
 
13844
fmod (const field_indirect<T1,M>& x, const field_component<T2,M>& y)
 
13845
{
 
13846
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
 
13847
}
 
13848
template<class T1, class T2, class M>
 
13849
typename boost::proto::result_of::make_expr<
 
13850
    boost::proto::tag::function,
 
13851
    field_domain,
 
13852
    const field_detail::fmod_,
 
13853
    const field_indirect<T1,M>&,
 
13854
    const field_component_const<T2,M>&
 
13855
  >::type
 
13856
fmod (const field_indirect<T1,M>& x, const field_component_const<T2,M>& y)
 
13857
{
 
13858
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
 
13859
}
 
13860
template<class T1, class T2, class M>
 
13861
typename boost::proto::result_of::make_expr<
 
13862
    boost::proto::tag::function,
 
13863
    field_domain,
 
13864
    const field_detail::fmod_,
4668
13865
    const field_indirect_const<T1,M>&,
4669
13866
    const field_basic<T2,M>&
4670
13867
  >::type
4696
13893
{
4697
13894
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
4698
13895
}
 
13896
template<class T1, class T2, class M>
 
13897
typename boost::proto::result_of::make_expr<
 
13898
    boost::proto::tag::function,
 
13899
    field_domain,
 
13900
    const field_detail::fmod_,
 
13901
    const field_indirect_const<T1,M>&,
 
13902
    const field_component<T2,M>&
 
13903
  >::type
 
13904
fmod (const field_indirect_const<T1,M>& x, const field_component<T2,M>& y)
 
13905
{
 
13906
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
 
13907
}
 
13908
template<class T1, class T2, class M>
 
13909
typename boost::proto::result_of::make_expr<
 
13910
    boost::proto::tag::function,
 
13911
    field_domain,
 
13912
    const field_detail::fmod_,
 
13913
    const field_indirect_const<T1,M>&,
 
13914
    const field_component_const<T2,M>&
 
13915
  >::type
 
13916
fmod (const field_indirect_const<T1,M>& x, const field_component_const<T2,M>& y)
 
13917
{
 
13918
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
 
13919
}
 
13920
template<class T1, class T2, class M>
 
13921
typename boost::proto::result_of::make_expr<
 
13922
    boost::proto::tag::function,
 
13923
    field_domain,
 
13924
    const field_detail::fmod_,
 
13925
    const field_component<T1,M>&,
 
13926
    const field_basic<T2,M>&
 
13927
  >::type
 
13928
fmod (const field_component<T1,M>& x, const field_basic<T2,M>& y)
 
13929
{
 
13930
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
 
13931
}
 
13932
template<class T1, class T2, class M>
 
13933
typename boost::proto::result_of::make_expr<
 
13934
    boost::proto::tag::function,
 
13935
    field_domain,
 
13936
    const field_detail::fmod_,
 
13937
    const field_component<T1,M>&,
 
13938
    const field_indirect<T2,M>&
 
13939
  >::type
 
13940
fmod (const field_component<T1,M>& x, const field_indirect<T2,M>& y)
 
13941
{
 
13942
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
 
13943
}
 
13944
template<class T1, class T2, class M>
 
13945
typename boost::proto::result_of::make_expr<
 
13946
    boost::proto::tag::function,
 
13947
    field_domain,
 
13948
    const field_detail::fmod_,
 
13949
    const field_component<T1,M>&,
 
13950
    const field_indirect_const<T2,M>&
 
13951
  >::type
 
13952
fmod (const field_component<T1,M>& x, const field_indirect_const<T2,M>& y)
 
13953
{
 
13954
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
 
13955
}
 
13956
template<class T1, class T2, class M>
 
13957
typename boost::proto::result_of::make_expr<
 
13958
    boost::proto::tag::function,
 
13959
    field_domain,
 
13960
    const field_detail::fmod_,
 
13961
    const field_component<T1,M>&,
 
13962
    const field_component<T2,M>&
 
13963
  >::type
 
13964
fmod (const field_component<T1,M>& x, const field_component<T2,M>& y)
 
13965
{
 
13966
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
 
13967
}
 
13968
template<class T1, class T2, class M>
 
13969
typename boost::proto::result_of::make_expr<
 
13970
    boost::proto::tag::function,
 
13971
    field_domain,
 
13972
    const field_detail::fmod_,
 
13973
    const field_component<T1,M>&,
 
13974
    const field_component_const<T2,M>&
 
13975
  >::type
 
13976
fmod (const field_component<T1,M>& x, const field_component_const<T2,M>& y)
 
13977
{
 
13978
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
 
13979
}
 
13980
template<class T1, class T2, class M>
 
13981
typename boost::proto::result_of::make_expr<
 
13982
    boost::proto::tag::function,
 
13983
    field_domain,
 
13984
    const field_detail::fmod_,
 
13985
    const field_component_const<T1,M>&,
 
13986
    const field_basic<T2,M>&
 
13987
  >::type
 
13988
fmod (const field_component_const<T1,M>& x, const field_basic<T2,M>& y)
 
13989
{
 
13990
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
 
13991
}
 
13992
template<class T1, class T2, class M>
 
13993
typename boost::proto::result_of::make_expr<
 
13994
    boost::proto::tag::function,
 
13995
    field_domain,
 
13996
    const field_detail::fmod_,
 
13997
    const field_component_const<T1,M>&,
 
13998
    const field_indirect<T2,M>&
 
13999
  >::type
 
14000
fmod (const field_component_const<T1,M>& x, const field_indirect<T2,M>& y)
 
14001
{
 
14002
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
 
14003
}
 
14004
template<class T1, class T2, class M>
 
14005
typename boost::proto::result_of::make_expr<
 
14006
    boost::proto::tag::function,
 
14007
    field_domain,
 
14008
    const field_detail::fmod_,
 
14009
    const field_component_const<T1,M>&,
 
14010
    const field_indirect_const<T2,M>&
 
14011
  >::type
 
14012
fmod (const field_component_const<T1,M>& x, const field_indirect_const<T2,M>& y)
 
14013
{
 
14014
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
 
14015
}
 
14016
template<class T1, class T2, class M>
 
14017
typename boost::proto::result_of::make_expr<
 
14018
    boost::proto::tag::function,
 
14019
    field_domain,
 
14020
    const field_detail::fmod_,
 
14021
    const field_component_const<T1,M>&,
 
14022
    const field_component<T2,M>&
 
14023
  >::type
 
14024
fmod (const field_component_const<T1,M>& x, const field_component<T2,M>& y)
 
14025
{
 
14026
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
 
14027
}
 
14028
template<class T1, class T2, class M>
 
14029
typename boost::proto::result_of::make_expr<
 
14030
    boost::proto::tag::function,
 
14031
    field_domain,
 
14032
    const field_detail::fmod_,
 
14033
    const field_component_const<T1,M>&,
 
14034
    const field_component_const<T2,M>&
 
14035
  >::type
 
14036
fmod (const field_component_const<T1,M>& x, const field_component_const<T2,M>& y)
 
14037
{
 
14038
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
 
14039
}
4699
14040
template<class Expr>
4700
14041
typename boost::proto::result_of::make_expr<
4701
14042
    boost::proto::tag::function,
4816
14157
{
4817
14158
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
4818
14159
}
 
14160
template<class T, class M, class Expr>
 
14161
typename boost::proto::result_of::make_expr<
 
14162
    boost::proto::tag::function,
 
14163
    field_domain,
 
14164
    const field_detail::fmod_,
 
14165
    const field_component<T,M>&,
 
14166
    const field_expr<Expr>&
 
14167
  >::type
 
14168
fmod (const field_component<T,M>& x, const field_expr<Expr>& y)
 
14169
{
 
14170
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
 
14171
}
 
14172
template<class T, class M, class Expr>
 
14173
typename boost::proto::result_of::make_expr<
 
14174
    boost::proto::tag::function,
 
14175
    field_domain,
 
14176
    const field_detail::fmod_,
 
14177
    const field_expr<Expr>&,
 
14178
    const field_component<T,M>&
 
14179
  >::type
 
14180
fmod (const field_expr<Expr>& x, const field_component<T,M>& y)
 
14181
{
 
14182
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
 
14183
}
 
14184
template<class T, class M, class Expr>
 
14185
typename boost::proto::result_of::make_expr<
 
14186
    boost::proto::tag::function,
 
14187
    field_domain,
 
14188
    const field_detail::fmod_,
 
14189
    const field_component_const<T,M>&,
 
14190
    const field_expr<Expr>&
 
14191
  >::type
 
14192
fmod (const field_component_const<T,M>& x, const field_expr<Expr>& y)
 
14193
{
 
14194
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
 
14195
}
 
14196
template<class T, class M, class Expr>
 
14197
typename boost::proto::result_of::make_expr<
 
14198
    boost::proto::tag::function,
 
14199
    field_domain,
 
14200
    const field_detail::fmod_,
 
14201
    const field_expr<Expr>&,
 
14202
    const field_component_const<T,M>&
 
14203
  >::type
 
14204
fmod (const field_expr<Expr>& x, const field_component_const<T,M>& y)
 
14205
{
 
14206
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::fmod_(), boost::ref(x), boost::ref(y));
 
14207
}
4819
14208
template<class Expr1, class Expr2>
4820
14209
typename boost::proto::result_of::make_expr<
4821
14210
    boost::proto::tag::function,
4924
14313
    boost::proto::tag::function,
4925
14314
    field_domain,
4926
14315
    const field_detail::min_,
 
14316
    const int&,
 
14317
    const field_component<T,M>&
 
14318
  >::type
 
14319
min (const int& x, const field_component<T,M>& y)
 
14320
{
 
14321
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
 
14322
}
 
14323
template<class T1, class T2, class M>
 
14324
typename boost::proto::result_of::make_expr<
 
14325
    boost::proto::tag::function,
 
14326
    field_domain,
 
14327
    const field_detail::min_,
 
14328
    const T1&,
 
14329
    const field_component<T2,M>&
 
14330
  >::type
 
14331
min (const T1& x, const field_component<T2,M>& y)
 
14332
{
 
14333
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
 
14334
}
 
14335
template<class T, class M>
 
14336
typename boost::proto::result_of::make_expr<
 
14337
    boost::proto::tag::function,
 
14338
    field_domain,
 
14339
    const field_detail::min_,
 
14340
    const int&,
 
14341
    const field_component_const<T,M>&
 
14342
  >::type
 
14343
min (const int& x, const field_component_const<T,M>& y)
 
14344
{
 
14345
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
 
14346
}
 
14347
template<class T1, class T2, class M>
 
14348
typename boost::proto::result_of::make_expr<
 
14349
    boost::proto::tag::function,
 
14350
    field_domain,
 
14351
    const field_detail::min_,
 
14352
    const T1&,
 
14353
    const field_component_const<T2,M>&
 
14354
  >::type
 
14355
min (const T1& x, const field_component_const<T2,M>& y)
 
14356
{
 
14357
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
 
14358
}
 
14359
template<class T, class M>
 
14360
typename boost::proto::result_of::make_expr<
 
14361
    boost::proto::tag::function,
 
14362
    field_domain,
 
14363
    const field_detail::min_,
4927
14364
    const field_basic<T,M>&,
4928
14365
    const int&
4929
14366
  >::type
4991
14428
{
4992
14429
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
4993
14430
}
 
14431
template<class T, class M>
 
14432
typename boost::proto::result_of::make_expr<
 
14433
    boost::proto::tag::function,
 
14434
    field_domain,
 
14435
    const field_detail::min_,
 
14436
    const field_component<T,M>&,
 
14437
    const int&
 
14438
  >::type
 
14439
min (const field_component<T,M>& x, const int& y)
 
14440
{
 
14441
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
 
14442
}
 
14443
template<class T1, class T2, class M>
 
14444
typename boost::proto::result_of::make_expr<
 
14445
    boost::proto::tag::function,
 
14446
    field_domain,
 
14447
    const field_detail::min_,
 
14448
    const field_component<T1,M>&,
 
14449
    const T2&
 
14450
  >::type
 
14451
min (const field_component<T1,M>& x, const T2& y)
 
14452
{
 
14453
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
 
14454
}
 
14455
template<class T, class M>
 
14456
typename boost::proto::result_of::make_expr<
 
14457
    boost::proto::tag::function,
 
14458
    field_domain,
 
14459
    const field_detail::min_,
 
14460
    const field_component_const<T,M>&,
 
14461
    const int&
 
14462
  >::type
 
14463
min (const field_component_const<T,M>& x, const int& y)
 
14464
{
 
14465
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
 
14466
}
 
14467
template<class T1, class T2, class M>
 
14468
typename boost::proto::result_of::make_expr<
 
14469
    boost::proto::tag::function,
 
14470
    field_domain,
 
14471
    const field_detail::min_,
 
14472
    const field_component_const<T1,M>&,
 
14473
    const T2&
 
14474
  >::type
 
14475
min (const field_component_const<T1,M>& x, const T2& y)
 
14476
{
 
14477
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
 
14478
}
4994
14479
template<class T1, class T2, class M>
4995
14480
typename boost::proto::result_of::make_expr<
4996
14481
    boost::proto::tag::function,
5032
14517
    boost::proto::tag::function,
5033
14518
    field_domain,
5034
14519
    const field_detail::min_,
 
14520
    const field_basic<T1,M>&,
 
14521
    const field_component<T2,M>&
 
14522
  >::type
 
14523
min (const field_basic<T1,M>& x, const field_component<T2,M>& y)
 
14524
{
 
14525
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
 
14526
}
 
14527
template<class T1, class T2, class M>
 
14528
typename boost::proto::result_of::make_expr<
 
14529
    boost::proto::tag::function,
 
14530
    field_domain,
 
14531
    const field_detail::min_,
 
14532
    const field_basic<T1,M>&,
 
14533
    const field_component_const<T2,M>&
 
14534
  >::type
 
14535
min (const field_basic<T1,M>& x, const field_component_const<T2,M>& y)
 
14536
{
 
14537
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
 
14538
}
 
14539
template<class T1, class T2, class M>
 
14540
typename boost::proto::result_of::make_expr<
 
14541
    boost::proto::tag::function,
 
14542
    field_domain,
 
14543
    const field_detail::min_,
5035
14544
    const field_indirect<T1,M>&,
5036
14545
    const field_basic<T2,M>&
5037
14546
  >::type
5068
14577
    boost::proto::tag::function,
5069
14578
    field_domain,
5070
14579
    const field_detail::min_,
 
14580
    const field_indirect<T1,M>&,
 
14581
    const field_component<T2,M>&
 
14582
  >::type
 
14583
min (const field_indirect<T1,M>& x, const field_component<T2,M>& y)
 
14584
{
 
14585
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
 
14586
}
 
14587
template<class T1, class T2, class M>
 
14588
typename boost::proto::result_of::make_expr<
 
14589
    boost::proto::tag::function,
 
14590
    field_domain,
 
14591
    const field_detail::min_,
 
14592
    const field_indirect<T1,M>&,
 
14593
    const field_component_const<T2,M>&
 
14594
  >::type
 
14595
min (const field_indirect<T1,M>& x, const field_component_const<T2,M>& y)
 
14596
{
 
14597
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
 
14598
}
 
14599
template<class T1, class T2, class M>
 
14600
typename boost::proto::result_of::make_expr<
 
14601
    boost::proto::tag::function,
 
14602
    field_domain,
 
14603
    const field_detail::min_,
5071
14604
    const field_indirect_const<T1,M>&,
5072
14605
    const field_basic<T2,M>&
5073
14606
  >::type
5099
14632
{
5100
14633
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
5101
14634
}
 
14635
template<class T1, class T2, class M>
 
14636
typename boost::proto::result_of::make_expr<
 
14637
    boost::proto::tag::function,
 
14638
    field_domain,
 
14639
    const field_detail::min_,
 
14640
    const field_indirect_const<T1,M>&,
 
14641
    const field_component<T2,M>&
 
14642
  >::type
 
14643
min (const field_indirect_const<T1,M>& x, const field_component<T2,M>& y)
 
14644
{
 
14645
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
 
14646
}
 
14647
template<class T1, class T2, class M>
 
14648
typename boost::proto::result_of::make_expr<
 
14649
    boost::proto::tag::function,
 
14650
    field_domain,
 
14651
    const field_detail::min_,
 
14652
    const field_indirect_const<T1,M>&,
 
14653
    const field_component_const<T2,M>&
 
14654
  >::type
 
14655
min (const field_indirect_const<T1,M>& x, const field_component_const<T2,M>& y)
 
14656
{
 
14657
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
 
14658
}
 
14659
template<class T1, class T2, class M>
 
14660
typename boost::proto::result_of::make_expr<
 
14661
    boost::proto::tag::function,
 
14662
    field_domain,
 
14663
    const field_detail::min_,
 
14664
    const field_component<T1,M>&,
 
14665
    const field_basic<T2,M>&
 
14666
  >::type
 
14667
min (const field_component<T1,M>& x, const field_basic<T2,M>& y)
 
14668
{
 
14669
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
 
14670
}
 
14671
template<class T1, class T2, class M>
 
14672
typename boost::proto::result_of::make_expr<
 
14673
    boost::proto::tag::function,
 
14674
    field_domain,
 
14675
    const field_detail::min_,
 
14676
    const field_component<T1,M>&,
 
14677
    const field_indirect<T2,M>&
 
14678
  >::type
 
14679
min (const field_component<T1,M>& x, const field_indirect<T2,M>& y)
 
14680
{
 
14681
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
 
14682
}
 
14683
template<class T1, class T2, class M>
 
14684
typename boost::proto::result_of::make_expr<
 
14685
    boost::proto::tag::function,
 
14686
    field_domain,
 
14687
    const field_detail::min_,
 
14688
    const field_component<T1,M>&,
 
14689
    const field_indirect_const<T2,M>&
 
14690
  >::type
 
14691
min (const field_component<T1,M>& x, const field_indirect_const<T2,M>& y)
 
14692
{
 
14693
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
 
14694
}
 
14695
template<class T1, class T2, class M>
 
14696
typename boost::proto::result_of::make_expr<
 
14697
    boost::proto::tag::function,
 
14698
    field_domain,
 
14699
    const field_detail::min_,
 
14700
    const field_component<T1,M>&,
 
14701
    const field_component<T2,M>&
 
14702
  >::type
 
14703
min (const field_component<T1,M>& x, const field_component<T2,M>& y)
 
14704
{
 
14705
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
 
14706
}
 
14707
template<class T1, class T2, class M>
 
14708
typename boost::proto::result_of::make_expr<
 
14709
    boost::proto::tag::function,
 
14710
    field_domain,
 
14711
    const field_detail::min_,
 
14712
    const field_component<T1,M>&,
 
14713
    const field_component_const<T2,M>&
 
14714
  >::type
 
14715
min (const field_component<T1,M>& x, const field_component_const<T2,M>& y)
 
14716
{
 
14717
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
 
14718
}
 
14719
template<class T1, class T2, class M>
 
14720
typename boost::proto::result_of::make_expr<
 
14721
    boost::proto::tag::function,
 
14722
    field_domain,
 
14723
    const field_detail::min_,
 
14724
    const field_component_const<T1,M>&,
 
14725
    const field_basic<T2,M>&
 
14726
  >::type
 
14727
min (const field_component_const<T1,M>& x, const field_basic<T2,M>& y)
 
14728
{
 
14729
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
 
14730
}
 
14731
template<class T1, class T2, class M>
 
14732
typename boost::proto::result_of::make_expr<
 
14733
    boost::proto::tag::function,
 
14734
    field_domain,
 
14735
    const field_detail::min_,
 
14736
    const field_component_const<T1,M>&,
 
14737
    const field_indirect<T2,M>&
 
14738
  >::type
 
14739
min (const field_component_const<T1,M>& x, const field_indirect<T2,M>& y)
 
14740
{
 
14741
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
 
14742
}
 
14743
template<class T1, class T2, class M>
 
14744
typename boost::proto::result_of::make_expr<
 
14745
    boost::proto::tag::function,
 
14746
    field_domain,
 
14747
    const field_detail::min_,
 
14748
    const field_component_const<T1,M>&,
 
14749
    const field_indirect_const<T2,M>&
 
14750
  >::type
 
14751
min (const field_component_const<T1,M>& x, const field_indirect_const<T2,M>& y)
 
14752
{
 
14753
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
 
14754
}
 
14755
template<class T1, class T2, class M>
 
14756
typename boost::proto::result_of::make_expr<
 
14757
    boost::proto::tag::function,
 
14758
    field_domain,
 
14759
    const field_detail::min_,
 
14760
    const field_component_const<T1,M>&,
 
14761
    const field_component<T2,M>&
 
14762
  >::type
 
14763
min (const field_component_const<T1,M>& x, const field_component<T2,M>& y)
 
14764
{
 
14765
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
 
14766
}
 
14767
template<class T1, class T2, class M>
 
14768
typename boost::proto::result_of::make_expr<
 
14769
    boost::proto::tag::function,
 
14770
    field_domain,
 
14771
    const field_detail::min_,
 
14772
    const field_component_const<T1,M>&,
 
14773
    const field_component_const<T2,M>&
 
14774
  >::type
 
14775
min (const field_component_const<T1,M>& x, const field_component_const<T2,M>& y)
 
14776
{
 
14777
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
 
14778
}
5102
14779
template<class Expr>
5103
14780
typename boost::proto::result_of::make_expr<
5104
14781
    boost::proto::tag::function,
5219
14896
{
5220
14897
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
5221
14898
}
 
14899
template<class T, class M, class Expr>
 
14900
typename boost::proto::result_of::make_expr<
 
14901
    boost::proto::tag::function,
 
14902
    field_domain,
 
14903
    const field_detail::min_,
 
14904
    const field_component<T,M>&,
 
14905
    const field_expr<Expr>&
 
14906
  >::type
 
14907
min (const field_component<T,M>& x, const field_expr<Expr>& y)
 
14908
{
 
14909
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
 
14910
}
 
14911
template<class T, class M, class Expr>
 
14912
typename boost::proto::result_of::make_expr<
 
14913
    boost::proto::tag::function,
 
14914
    field_domain,
 
14915
    const field_detail::min_,
 
14916
    const field_expr<Expr>&,
 
14917
    const field_component<T,M>&
 
14918
  >::type
 
14919
min (const field_expr<Expr>& x, const field_component<T,M>& y)
 
14920
{
 
14921
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
 
14922
}
 
14923
template<class T, class M, class Expr>
 
14924
typename boost::proto::result_of::make_expr<
 
14925
    boost::proto::tag::function,
 
14926
    field_domain,
 
14927
    const field_detail::min_,
 
14928
    const field_component_const<T,M>&,
 
14929
    const field_expr<Expr>&
 
14930
  >::type
 
14931
min (const field_component_const<T,M>& x, const field_expr<Expr>& y)
 
14932
{
 
14933
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
 
14934
}
 
14935
template<class T, class M, class Expr>
 
14936
typename boost::proto::result_of::make_expr<
 
14937
    boost::proto::tag::function,
 
14938
    field_domain,
 
14939
    const field_detail::min_,
 
14940
    const field_expr<Expr>&,
 
14941
    const field_component_const<T,M>&
 
14942
  >::type
 
14943
min (const field_expr<Expr>& x, const field_component_const<T,M>& y)
 
14944
{
 
14945
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::min_(), boost::ref(x), boost::ref(y));
 
14946
}
5222
14947
template<class Expr1, class Expr2>
5223
14948
typename boost::proto::result_of::make_expr<
5224
14949
    boost::proto::tag::function,
5327
15052
    boost::proto::tag::function,
5328
15053
    field_domain,
5329
15054
    const field_detail::max_,
 
15055
    const int&,
 
15056
    const field_component<T,M>&
 
15057
  >::type
 
15058
max (const int& x, const field_component<T,M>& y)
 
15059
{
 
15060
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
 
15061
}
 
15062
template<class T1, class T2, class M>
 
15063
typename boost::proto::result_of::make_expr<
 
15064
    boost::proto::tag::function,
 
15065
    field_domain,
 
15066
    const field_detail::max_,
 
15067
    const T1&,
 
15068
    const field_component<T2,M>&
 
15069
  >::type
 
15070
max (const T1& x, const field_component<T2,M>& y)
 
15071
{
 
15072
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
 
15073
}
 
15074
template<class T, class M>
 
15075
typename boost::proto::result_of::make_expr<
 
15076
    boost::proto::tag::function,
 
15077
    field_domain,
 
15078
    const field_detail::max_,
 
15079
    const int&,
 
15080
    const field_component_const<T,M>&
 
15081
  >::type
 
15082
max (const int& x, const field_component_const<T,M>& y)
 
15083
{
 
15084
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
 
15085
}
 
15086
template<class T1, class T2, class M>
 
15087
typename boost::proto::result_of::make_expr<
 
15088
    boost::proto::tag::function,
 
15089
    field_domain,
 
15090
    const field_detail::max_,
 
15091
    const T1&,
 
15092
    const field_component_const<T2,M>&
 
15093
  >::type
 
15094
max (const T1& x, const field_component_const<T2,M>& y)
 
15095
{
 
15096
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
 
15097
}
 
15098
template<class T, class M>
 
15099
typename boost::proto::result_of::make_expr<
 
15100
    boost::proto::tag::function,
 
15101
    field_domain,
 
15102
    const field_detail::max_,
5330
15103
    const field_basic<T,M>&,
5331
15104
    const int&
5332
15105
  >::type
5394
15167
{
5395
15168
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
5396
15169
}
 
15170
template<class T, class M>
 
15171
typename boost::proto::result_of::make_expr<
 
15172
    boost::proto::tag::function,
 
15173
    field_domain,
 
15174
    const field_detail::max_,
 
15175
    const field_component<T,M>&,
 
15176
    const int&
 
15177
  >::type
 
15178
max (const field_component<T,M>& x, const int& y)
 
15179
{
 
15180
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
 
15181
}
 
15182
template<class T1, class T2, class M>
 
15183
typename boost::proto::result_of::make_expr<
 
15184
    boost::proto::tag::function,
 
15185
    field_domain,
 
15186
    const field_detail::max_,
 
15187
    const field_component<T1,M>&,
 
15188
    const T2&
 
15189
  >::type
 
15190
max (const field_component<T1,M>& x, const T2& y)
 
15191
{
 
15192
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
 
15193
}
 
15194
template<class T, class M>
 
15195
typename boost::proto::result_of::make_expr<
 
15196
    boost::proto::tag::function,
 
15197
    field_domain,
 
15198
    const field_detail::max_,
 
15199
    const field_component_const<T,M>&,
 
15200
    const int&
 
15201
  >::type
 
15202
max (const field_component_const<T,M>& x, const int& y)
 
15203
{
 
15204
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
 
15205
}
 
15206
template<class T1, class T2, class M>
 
15207
typename boost::proto::result_of::make_expr<
 
15208
    boost::proto::tag::function,
 
15209
    field_domain,
 
15210
    const field_detail::max_,
 
15211
    const field_component_const<T1,M>&,
 
15212
    const T2&
 
15213
  >::type
 
15214
max (const field_component_const<T1,M>& x, const T2& y)
 
15215
{
 
15216
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
 
15217
}
5397
15218
template<class T1, class T2, class M>
5398
15219
typename boost::proto::result_of::make_expr<
5399
15220
    boost::proto::tag::function,
5435
15256
    boost::proto::tag::function,
5436
15257
    field_domain,
5437
15258
    const field_detail::max_,
 
15259
    const field_basic<T1,M>&,
 
15260
    const field_component<T2,M>&
 
15261
  >::type
 
15262
max (const field_basic<T1,M>& x, const field_component<T2,M>& y)
 
15263
{
 
15264
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
 
15265
}
 
15266
template<class T1, class T2, class M>
 
15267
typename boost::proto::result_of::make_expr<
 
15268
    boost::proto::tag::function,
 
15269
    field_domain,
 
15270
    const field_detail::max_,
 
15271
    const field_basic<T1,M>&,
 
15272
    const field_component_const<T2,M>&
 
15273
  >::type
 
15274
max (const field_basic<T1,M>& x, const field_component_const<T2,M>& y)
 
15275
{
 
15276
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
 
15277
}
 
15278
template<class T1, class T2, class M>
 
15279
typename boost::proto::result_of::make_expr<
 
15280
    boost::proto::tag::function,
 
15281
    field_domain,
 
15282
    const field_detail::max_,
5438
15283
    const field_indirect<T1,M>&,
5439
15284
    const field_basic<T2,M>&
5440
15285
  >::type
5471
15316
    boost::proto::tag::function,
5472
15317
    field_domain,
5473
15318
    const field_detail::max_,
 
15319
    const field_indirect<T1,M>&,
 
15320
    const field_component<T2,M>&
 
15321
  >::type
 
15322
max (const field_indirect<T1,M>& x, const field_component<T2,M>& y)
 
15323
{
 
15324
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
 
15325
}
 
15326
template<class T1, class T2, class M>
 
15327
typename boost::proto::result_of::make_expr<
 
15328
    boost::proto::tag::function,
 
15329
    field_domain,
 
15330
    const field_detail::max_,
 
15331
    const field_indirect<T1,M>&,
 
15332
    const field_component_const<T2,M>&
 
15333
  >::type
 
15334
max (const field_indirect<T1,M>& x, const field_component_const<T2,M>& y)
 
15335
{
 
15336
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
 
15337
}
 
15338
template<class T1, class T2, class M>
 
15339
typename boost::proto::result_of::make_expr<
 
15340
    boost::proto::tag::function,
 
15341
    field_domain,
 
15342
    const field_detail::max_,
5474
15343
    const field_indirect_const<T1,M>&,
5475
15344
    const field_basic<T2,M>&
5476
15345
  >::type
5502
15371
{
5503
15372
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
5504
15373
}
 
15374
template<class T1, class T2, class M>
 
15375
typename boost::proto::result_of::make_expr<
 
15376
    boost::proto::tag::function,
 
15377
    field_domain,
 
15378
    const field_detail::max_,
 
15379
    const field_indirect_const<T1,M>&,
 
15380
    const field_component<T2,M>&
 
15381
  >::type
 
15382
max (const field_indirect_const<T1,M>& x, const field_component<T2,M>& y)
 
15383
{
 
15384
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
 
15385
}
 
15386
template<class T1, class T2, class M>
 
15387
typename boost::proto::result_of::make_expr<
 
15388
    boost::proto::tag::function,
 
15389
    field_domain,
 
15390
    const field_detail::max_,
 
15391
    const field_indirect_const<T1,M>&,
 
15392
    const field_component_const<T2,M>&
 
15393
  >::type
 
15394
max (const field_indirect_const<T1,M>& x, const field_component_const<T2,M>& y)
 
15395
{
 
15396
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
 
15397
}
 
15398
template<class T1, class T2, class M>
 
15399
typename boost::proto::result_of::make_expr<
 
15400
    boost::proto::tag::function,
 
15401
    field_domain,
 
15402
    const field_detail::max_,
 
15403
    const field_component<T1,M>&,
 
15404
    const field_basic<T2,M>&
 
15405
  >::type
 
15406
max (const field_component<T1,M>& x, const field_basic<T2,M>& y)
 
15407
{
 
15408
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
 
15409
}
 
15410
template<class T1, class T2, class M>
 
15411
typename boost::proto::result_of::make_expr<
 
15412
    boost::proto::tag::function,
 
15413
    field_domain,
 
15414
    const field_detail::max_,
 
15415
    const field_component<T1,M>&,
 
15416
    const field_indirect<T2,M>&
 
15417
  >::type
 
15418
max (const field_component<T1,M>& x, const field_indirect<T2,M>& y)
 
15419
{
 
15420
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
 
15421
}
 
15422
template<class T1, class T2, class M>
 
15423
typename boost::proto::result_of::make_expr<
 
15424
    boost::proto::tag::function,
 
15425
    field_domain,
 
15426
    const field_detail::max_,
 
15427
    const field_component<T1,M>&,
 
15428
    const field_indirect_const<T2,M>&
 
15429
  >::type
 
15430
max (const field_component<T1,M>& x, const field_indirect_const<T2,M>& y)
 
15431
{
 
15432
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
 
15433
}
 
15434
template<class T1, class T2, class M>
 
15435
typename boost::proto::result_of::make_expr<
 
15436
    boost::proto::tag::function,
 
15437
    field_domain,
 
15438
    const field_detail::max_,
 
15439
    const field_component<T1,M>&,
 
15440
    const field_component<T2,M>&
 
15441
  >::type
 
15442
max (const field_component<T1,M>& x, const field_component<T2,M>& y)
 
15443
{
 
15444
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
 
15445
}
 
15446
template<class T1, class T2, class M>
 
15447
typename boost::proto::result_of::make_expr<
 
15448
    boost::proto::tag::function,
 
15449
    field_domain,
 
15450
    const field_detail::max_,
 
15451
    const field_component<T1,M>&,
 
15452
    const field_component_const<T2,M>&
 
15453
  >::type
 
15454
max (const field_component<T1,M>& x, const field_component_const<T2,M>& y)
 
15455
{
 
15456
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
 
15457
}
 
15458
template<class T1, class T2, class M>
 
15459
typename boost::proto::result_of::make_expr<
 
15460
    boost::proto::tag::function,
 
15461
    field_domain,
 
15462
    const field_detail::max_,
 
15463
    const field_component_const<T1,M>&,
 
15464
    const field_basic<T2,M>&
 
15465
  >::type
 
15466
max (const field_component_const<T1,M>& x, const field_basic<T2,M>& y)
 
15467
{
 
15468
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
 
15469
}
 
15470
template<class T1, class T2, class M>
 
15471
typename boost::proto::result_of::make_expr<
 
15472
    boost::proto::tag::function,
 
15473
    field_domain,
 
15474
    const field_detail::max_,
 
15475
    const field_component_const<T1,M>&,
 
15476
    const field_indirect<T2,M>&
 
15477
  >::type
 
15478
max (const field_component_const<T1,M>& x, const field_indirect<T2,M>& y)
 
15479
{
 
15480
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
 
15481
}
 
15482
template<class T1, class T2, class M>
 
15483
typename boost::proto::result_of::make_expr<
 
15484
    boost::proto::tag::function,
 
15485
    field_domain,
 
15486
    const field_detail::max_,
 
15487
    const field_component_const<T1,M>&,
 
15488
    const field_indirect_const<T2,M>&
 
15489
  >::type
 
15490
max (const field_component_const<T1,M>& x, const field_indirect_const<T2,M>& y)
 
15491
{
 
15492
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
 
15493
}
 
15494
template<class T1, class T2, class M>
 
15495
typename boost::proto::result_of::make_expr<
 
15496
    boost::proto::tag::function,
 
15497
    field_domain,
 
15498
    const field_detail::max_,
 
15499
    const field_component_const<T1,M>&,
 
15500
    const field_component<T2,M>&
 
15501
  >::type
 
15502
max (const field_component_const<T1,M>& x, const field_component<T2,M>& y)
 
15503
{
 
15504
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
 
15505
}
 
15506
template<class T1, class T2, class M>
 
15507
typename boost::proto::result_of::make_expr<
 
15508
    boost::proto::tag::function,
 
15509
    field_domain,
 
15510
    const field_detail::max_,
 
15511
    const field_component_const<T1,M>&,
 
15512
    const field_component_const<T2,M>&
 
15513
  >::type
 
15514
max (const field_component_const<T1,M>& x, const field_component_const<T2,M>& y)
 
15515
{
 
15516
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
 
15517
}
5505
15518
template<class Expr>
5506
15519
typename boost::proto::result_of::make_expr<
5507
15520
    boost::proto::tag::function,
5622
15635
{
5623
15636
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
5624
15637
}
 
15638
template<class T, class M, class Expr>
 
15639
typename boost::proto::result_of::make_expr<
 
15640
    boost::proto::tag::function,
 
15641
    field_domain,
 
15642
    const field_detail::max_,
 
15643
    const field_component<T,M>&,
 
15644
    const field_expr<Expr>&
 
15645
  >::type
 
15646
max (const field_component<T,M>& x, const field_expr<Expr>& y)
 
15647
{
 
15648
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
 
15649
}
 
15650
template<class T, class M, class Expr>
 
15651
typename boost::proto::result_of::make_expr<
 
15652
    boost::proto::tag::function,
 
15653
    field_domain,
 
15654
    const field_detail::max_,
 
15655
    const field_expr<Expr>&,
 
15656
    const field_component<T,M>&
 
15657
  >::type
 
15658
max (const field_expr<Expr>& x, const field_component<T,M>& y)
 
15659
{
 
15660
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
 
15661
}
 
15662
template<class T, class M, class Expr>
 
15663
typename boost::proto::result_of::make_expr<
 
15664
    boost::proto::tag::function,
 
15665
    field_domain,
 
15666
    const field_detail::max_,
 
15667
    const field_component_const<T,M>&,
 
15668
    const field_expr<Expr>&
 
15669
  >::type
 
15670
max (const field_component_const<T,M>& x, const field_expr<Expr>& y)
 
15671
{
 
15672
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
 
15673
}
 
15674
template<class T, class M, class Expr>
 
15675
typename boost::proto::result_of::make_expr<
 
15676
    boost::proto::tag::function,
 
15677
    field_domain,
 
15678
    const field_detail::max_,
 
15679
    const field_expr<Expr>&,
 
15680
    const field_component_const<T,M>&
 
15681
  >::type
 
15682
max (const field_expr<Expr>& x, const field_component_const<T,M>& y)
 
15683
{
 
15684
    return boost::proto::make_expr<boost::proto::tag::function, field_domain> (field_detail::max_(), boost::ref(x), boost::ref(y));
 
15685
}
5625
15686
template<class Expr1, class Expr2>
5626
15687
typename boost::proto::result_of::make_expr<
5627
15688
    boost::proto::tag::function,
5697
15758
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
5698
15759
        (field_detail::compose_<Function>(f), boost::ref(x));
5699
15760
}
 
15761
template<class Function, class T, class M>
 
15762
typename boost::proto::result_of::make_expr<
 
15763
    boost::proto::tag::function,
 
15764
    field_domain,
 
15765
    const field_detail::compose_<Function>,
 
15766
    const field_component<T,M>&
 
15767
  >::type
 
15768
compose (const Function& f, const field_component<T,M>& x)
 
15769
{
 
15770
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
15771
        (field_detail::compose_<Function>(f), boost::ref(x));
 
15772
}
 
15773
template<class Function, class T, class M>
 
15774
typename boost::proto::result_of::make_expr<
 
15775
    boost::proto::tag::function,
 
15776
    field_domain,
 
15777
    const field_detail::compose_<Function>,
 
15778
    const field_component_const<T,M>&
 
15779
  >::type
 
15780
compose (const Function& f, const field_component_const<T,M>& x)
 
15781
{
 
15782
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
15783
        (field_detail::compose_<Function>(f), boost::ref(x));
 
15784
}
5700
15785
template<class Function, class Expr>
5701
15786
typename boost::proto::result_of::make_expr<
5702
15787
    boost::proto::tag::function,
5903
15988
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
5904
15989
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
5905
15990
}
 
15991
template<class Function, class T, class M>
 
15992
typename boost::proto::result_of::make_expr<
 
15993
    boost::proto::tag::function,
 
15994
    field_domain,
 
15995
    const field_detail::compose2_<Function>,
 
15996
    const int&,
 
15997
    const field_component<T,M>&
 
15998
  >::type
 
15999
compose (const Function& f, const int& x, const field_component<T,M>& y)
 
16000
{
 
16001
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
16002
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
 
16003
}
 
16004
template<class Function, class T, class M>
 
16005
typename boost::proto::result_of::make_expr<
 
16006
    boost::proto::tag::function,
 
16007
    field_domain,
 
16008
    const field_detail::compose2_<Function>,
 
16009
    const field_component<T,M>&,
 
16010
    const int&
 
16011
  >::type
 
16012
compose (const Function& f, const field_component<T,M>& x, const int& y)
 
16013
{
 
16014
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
16015
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
 
16016
}
 
16017
template<class Function, class T1, class T2, class M>
 
16018
typename boost::proto::result_of::make_expr<
 
16019
    boost::proto::tag::function,
 
16020
    field_domain,
 
16021
    const field_detail::compose2_<Function>,
 
16022
    const T1&,
 
16023
    const field_component<T2,M>&
 
16024
  >::type
 
16025
compose (const Function& f, const T1& x, const field_component<T2,M>& y)
 
16026
{
 
16027
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
16028
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
 
16029
}
 
16030
template<class Function, class T1, class T2, class M>
 
16031
typename boost::proto::result_of::make_expr<
 
16032
    boost::proto::tag::function,
 
16033
    field_domain,
 
16034
    const field_detail::compose2_<Function>,
 
16035
    const field_component<T1,M>&,
 
16036
    const T2&
 
16037
  >::type
 
16038
compose (const Function& f, const field_component<T1,M>& x, const T2& y)
 
16039
{
 
16040
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
16041
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
 
16042
}
 
16043
template<class Function, class T, class M>
 
16044
typename boost::proto::result_of::make_expr<
 
16045
    boost::proto::tag::function,
 
16046
    field_domain,
 
16047
    const field_detail::compose2_<Function>,
 
16048
    const int&,
 
16049
    const field_component_const<T,M>&
 
16050
  >::type
 
16051
compose (const Function& f, const int& x, const field_component_const<T,M>& y)
 
16052
{
 
16053
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
16054
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
 
16055
}
 
16056
template<class Function, class T, class M>
 
16057
typename boost::proto::result_of::make_expr<
 
16058
    boost::proto::tag::function,
 
16059
    field_domain,
 
16060
    const field_detail::compose2_<Function>,
 
16061
    const field_component_const<T,M>&,
 
16062
    const int&
 
16063
  >::type
 
16064
compose (const Function& f, const field_component_const<T,M>& x, const int& y)
 
16065
{
 
16066
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
16067
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
 
16068
}
 
16069
template<class Function, class T1, class T2, class M>
 
16070
typename boost::proto::result_of::make_expr<
 
16071
    boost::proto::tag::function,
 
16072
    field_domain,
 
16073
    const field_detail::compose2_<Function>,
 
16074
    const T1&,
 
16075
    const field_component_const<T2,M>&
 
16076
  >::type
 
16077
compose (const Function& f, const T1& x, const field_component_const<T2,M>& y)
 
16078
{
 
16079
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
16080
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
 
16081
}
 
16082
template<class Function, class T1, class T2, class M>
 
16083
typename boost::proto::result_of::make_expr<
 
16084
    boost::proto::tag::function,
 
16085
    field_domain,
 
16086
    const field_detail::compose2_<Function>,
 
16087
    const field_component_const<T1,M>&,
 
16088
    const T2&
 
16089
  >::type
 
16090
compose (const Function& f, const field_component_const<T1,M>& x, const T2& y)
 
16091
{
 
16092
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
16093
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
 
16094
}
5906
16095
template<class Function, class T1, class T2, class M>
5907
16096
typename boost::proto::result_of::make_expr<
5908
16097
    boost::proto::tag::function,
5947
16136
    boost::proto::tag::function,
5948
16137
    field_domain,
5949
16138
    const field_detail::compose2_<Function>,
 
16139
    const field_basic<T1,M>&,
 
16140
    const field_component<T2,M>&
 
16141
  >::type
 
16142
compose (const Function& f, const field_basic<T1,M>& x, const field_component<T2,M>& y)
 
16143
{
 
16144
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
16145
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
 
16146
}
 
16147
template<class Function, class T1, class T2, class M>
 
16148
typename boost::proto::result_of::make_expr<
 
16149
    boost::proto::tag::function,
 
16150
    field_domain,
 
16151
    const field_detail::compose2_<Function>,
 
16152
    const field_basic<T1,M>&,
 
16153
    const field_component_const<T2,M>&
 
16154
  >::type
 
16155
compose (const Function& f, const field_basic<T1,M>& x, const field_component_const<T2,M>& y)
 
16156
{
 
16157
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
16158
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
 
16159
}
 
16160
template<class Function, class T1, class T2, class M>
 
16161
typename boost::proto::result_of::make_expr<
 
16162
    boost::proto::tag::function,
 
16163
    field_domain,
 
16164
    const field_detail::compose2_<Function>,
5950
16165
    const field_indirect<T1,M>&,
5951
16166
    const field_basic<T2,M>&
5952
16167
  >::type
5986
16201
    boost::proto::tag::function,
5987
16202
    field_domain,
5988
16203
    const field_detail::compose2_<Function>,
 
16204
    const field_indirect<T1,M>&,
 
16205
    const field_component<T2,M>&
 
16206
  >::type
 
16207
compose (const Function& f, const field_indirect<T1,M>& x, const field_component<T2,M>& y)
 
16208
{
 
16209
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
16210
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
 
16211
}
 
16212
template<class Function, class T1, class T2, class M>
 
16213
typename boost::proto::result_of::make_expr<
 
16214
    boost::proto::tag::function,
 
16215
    field_domain,
 
16216
    const field_detail::compose2_<Function>,
 
16217
    const field_indirect<T1,M>&,
 
16218
    const field_component_const<T2,M>&
 
16219
  >::type
 
16220
compose (const Function& f, const field_indirect<T1,M>& x, const field_component_const<T2,M>& y)
 
16221
{
 
16222
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
16223
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
 
16224
}
 
16225
template<class Function, class T1, class T2, class M>
 
16226
typename boost::proto::result_of::make_expr<
 
16227
    boost::proto::tag::function,
 
16228
    field_domain,
 
16229
    const field_detail::compose2_<Function>,
5989
16230
    const field_indirect_const<T1,M>&,
5990
16231
    const field_basic<T2,M>&
5991
16232
  >::type
6020
16261
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
6021
16262
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
6022
16263
}
 
16264
template<class Function, class T1, class T2, class M>
 
16265
typename boost::proto::result_of::make_expr<
 
16266
    boost::proto::tag::function,
 
16267
    field_domain,
 
16268
    const field_detail::compose2_<Function>,
 
16269
    const field_indirect_const<T1,M>&,
 
16270
    const field_component<T2,M>&
 
16271
  >::type
 
16272
compose (const Function& f, const field_indirect_const<T1,M>& x, const field_component<T2,M>& y)
 
16273
{
 
16274
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
16275
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
 
16276
}
 
16277
template<class Function, class T1, class T2, class M>
 
16278
typename boost::proto::result_of::make_expr<
 
16279
    boost::proto::tag::function,
 
16280
    field_domain,
 
16281
    const field_detail::compose2_<Function>,
 
16282
    const field_indirect_const<T1,M>&,
 
16283
    const field_component_const<T2,M>&
 
16284
  >::type
 
16285
compose (const Function& f, const field_indirect_const<T1,M>& x, const field_component_const<T2,M>& y)
 
16286
{
 
16287
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
16288
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
 
16289
}
 
16290
template<class Function, class T1, class T2, class M>
 
16291
typename boost::proto::result_of::make_expr<
 
16292
    boost::proto::tag::function,
 
16293
    field_domain,
 
16294
    const field_detail::compose2_<Function>,
 
16295
    const field_component<T1,M>&,
 
16296
    const field_basic<T2,M>&
 
16297
  >::type
 
16298
compose (const Function& f, const field_component<T1,M>& x, const field_basic<T2,M>& y)
 
16299
{
 
16300
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
16301
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
 
16302
}
 
16303
template<class Function, class T1, class T2, class M>
 
16304
typename boost::proto::result_of::make_expr<
 
16305
    boost::proto::tag::function,
 
16306
    field_domain,
 
16307
    const field_detail::compose2_<Function>,
 
16308
    const field_component<T1,M>&,
 
16309
    const field_indirect<T2,M>&
 
16310
  >::type
 
16311
compose (const Function& f, const field_component<T1,M>& x, const field_indirect<T2,M>& y)
 
16312
{
 
16313
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
16314
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
 
16315
}
 
16316
template<class Function, class T1, class T2, class M>
 
16317
typename boost::proto::result_of::make_expr<
 
16318
    boost::proto::tag::function,
 
16319
    field_domain,
 
16320
    const field_detail::compose2_<Function>,
 
16321
    const field_component<T1,M>&,
 
16322
    const field_indirect_const<T2,M>&
 
16323
  >::type
 
16324
compose (const Function& f, const field_component<T1,M>& x, const field_indirect_const<T2,M>& y)
 
16325
{
 
16326
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
16327
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
 
16328
}
 
16329
template<class Function, class T1, class T2, class M>
 
16330
typename boost::proto::result_of::make_expr<
 
16331
    boost::proto::tag::function,
 
16332
    field_domain,
 
16333
    const field_detail::compose2_<Function>,
 
16334
    const field_component<T1,M>&,
 
16335
    const field_component<T2,M>&
 
16336
  >::type
 
16337
compose (const Function& f, const field_component<T1,M>& x, const field_component<T2,M>& y)
 
16338
{
 
16339
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
16340
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
 
16341
}
 
16342
template<class Function, class T1, class T2, class M>
 
16343
typename boost::proto::result_of::make_expr<
 
16344
    boost::proto::tag::function,
 
16345
    field_domain,
 
16346
    const field_detail::compose2_<Function>,
 
16347
    const field_component<T1,M>&,
 
16348
    const field_component_const<T2,M>&
 
16349
  >::type
 
16350
compose (const Function& f, const field_component<T1,M>& x, const field_component_const<T2,M>& y)
 
16351
{
 
16352
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
16353
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
 
16354
}
 
16355
template<class Function, class T1, class T2, class M>
 
16356
typename boost::proto::result_of::make_expr<
 
16357
    boost::proto::tag::function,
 
16358
    field_domain,
 
16359
    const field_detail::compose2_<Function>,
 
16360
    const field_component_const<T1,M>&,
 
16361
    const field_basic<T2,M>&
 
16362
  >::type
 
16363
compose (const Function& f, const field_component_const<T1,M>& x, const field_basic<T2,M>& y)
 
16364
{
 
16365
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
16366
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
 
16367
}
 
16368
template<class Function, class T1, class T2, class M>
 
16369
typename boost::proto::result_of::make_expr<
 
16370
    boost::proto::tag::function,
 
16371
    field_domain,
 
16372
    const field_detail::compose2_<Function>,
 
16373
    const field_component_const<T1,M>&,
 
16374
    const field_indirect<T2,M>&
 
16375
  >::type
 
16376
compose (const Function& f, const field_component_const<T1,M>& x, const field_indirect<T2,M>& y)
 
16377
{
 
16378
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
16379
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
 
16380
}
 
16381
template<class Function, class T1, class T2, class M>
 
16382
typename boost::proto::result_of::make_expr<
 
16383
    boost::proto::tag::function,
 
16384
    field_domain,
 
16385
    const field_detail::compose2_<Function>,
 
16386
    const field_component_const<T1,M>&,
 
16387
    const field_indirect_const<T2,M>&
 
16388
  >::type
 
16389
compose (const Function& f, const field_component_const<T1,M>& x, const field_indirect_const<T2,M>& y)
 
16390
{
 
16391
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
16392
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
 
16393
}
 
16394
template<class Function, class T1, class T2, class M>
 
16395
typename boost::proto::result_of::make_expr<
 
16396
    boost::proto::tag::function,
 
16397
    field_domain,
 
16398
    const field_detail::compose2_<Function>,
 
16399
    const field_component_const<T1,M>&,
 
16400
    const field_component<T2,M>&
 
16401
  >::type
 
16402
compose (const Function& f, const field_component_const<T1,M>& x, const field_component<T2,M>& y)
 
16403
{
 
16404
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
16405
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
 
16406
}
 
16407
template<class Function, class T1, class T2, class M>
 
16408
typename boost::proto::result_of::make_expr<
 
16409
    boost::proto::tag::function,
 
16410
    field_domain,
 
16411
    const field_detail::compose2_<Function>,
 
16412
    const field_component_const<T1,M>&,
 
16413
    const field_component_const<T2,M>&
 
16414
  >::type
 
16415
compose (const Function& f, const field_component_const<T1,M>& x, const field_component_const<T2,M>& y)
 
16416
{
 
16417
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
16418
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
 
16419
}
6023
16420
template<class Function, class Expr>
6024
16421
typename boost::proto::result_of::make_expr<
6025
16422
    boost::proto::tag::function,
6150
16547
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
6151
16548
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
6152
16549
}
 
16550
template<class Function, class Expr, class T, class M>
 
16551
typename boost::proto::result_of::make_expr<
 
16552
    boost::proto::tag::function,
 
16553
    field_domain,
 
16554
    const field_detail::compose2_<Function>,
 
16555
    const field_component<T,M>&,
 
16556
    const field_expr<Expr>&
 
16557
  >::type
 
16558
compose (const Function& f, const field_component<T,M>& x, const field_expr<Expr>& y)
 
16559
{
 
16560
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
16561
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
 
16562
}
 
16563
template<class Function, class Expr, class T, class M>
 
16564
typename boost::proto::result_of::make_expr<
 
16565
    boost::proto::tag::function,
 
16566
    field_domain,
 
16567
    const field_detail::compose2_<Function>,
 
16568
    const field_expr<Expr>&,
 
16569
    const field_component<T,M>&
 
16570
  >::type
 
16571
compose (const Function& f, const field_expr<Expr>& x, const field_component<T,M>& y)
 
16572
{
 
16573
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
16574
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
 
16575
}
 
16576
template<class Function, class Expr, class T, class M>
 
16577
typename boost::proto::result_of::make_expr<
 
16578
    boost::proto::tag::function,
 
16579
    field_domain,
 
16580
    const field_detail::compose2_<Function>,
 
16581
    const field_component_const<T,M>&,
 
16582
    const field_expr<Expr>&
 
16583
  >::type
 
16584
compose (const Function& f, const field_component_const<T,M>& x, const field_expr<Expr>& y)
 
16585
{
 
16586
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
16587
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
 
16588
}
 
16589
template<class Function, class Expr, class T, class M>
 
16590
typename boost::proto::result_of::make_expr<
 
16591
    boost::proto::tag::function,
 
16592
    field_domain,
 
16593
    const field_detail::compose2_<Function>,
 
16594
    const field_expr<Expr>&,
 
16595
    const field_component_const<T,M>&
 
16596
  >::type
 
16597
compose (const Function& f, const field_expr<Expr>& x, const field_component_const<T,M>& y)
 
16598
{
 
16599
    return boost::proto::make_expr<boost::proto::tag::function, field_domain>
 
16600
        (field_detail::compose2_<Function>(f), boost::ref(x), boost::ref(y));
 
16601
}
6153
16602
template<class Function, class Expr1, class Expr2>
6154
16603
typename boost::proto::result_of::make_expr<
6155
16604
    boost::proto::tag::function,
6167
16616
T
6168
16617
dot (const field_basic<T,M>& x, const int& y)
6169
16618
{
6170
 
  return y*dis_accumulate (x.begin(), x.size(), x.ownership().comm());
 
16619
  return y*dis_accumulate (x.begin_dof(), x.ndof(), x.ownership().comm());
6171
16620
}
6172
16621
template <class T, class M>
6173
16622
T
6174
16623
dot (const int& x, const field_basic<T,M>& y)
6175
16624
{
6176
 
  return x*dis_accumulate (y.begin(), y.size(), y.ownership().comm());
 
16625
  return x*dis_accumulate (y.begin_dof(), y.ndof(), y.ownership().comm());
6177
16626
}
6178
16627
template <class T1, class T2, class M>
6179
16628
typename promote<T1,T2>::type
6180
16629
dot (const field_basic<T1,M>& x, const T2& y)
6181
16630
{
6182
 
  return y*dis_accumulate (x.begin(), x.size(), x.ownership().comm());
 
16631
  return y*dis_accumulate (x.begin_dof(), x.ndof(), x.ownership().comm());
6183
16632
}
6184
16633
template <class T1, class T2, class M>
6185
16634
typename promote<T1,T2>::type
6186
16635
dot (const T1& x, const field_basic<T2,M>& y)
6187
16636
{
6188
 
  return x*dis_accumulate (y.begin(), y.size(), y.ownership().comm());
 
16637
  return x*dis_accumulate (y.begin_dof(), y.ndof(), y.ownership().comm());
6189
16638
}
6190
16639
template <class T, class M>
6191
16640
T
6192
16641
dot (const field_indirect<T,M>& x, const int& y)
6193
16642
{
6194
 
  return y*dis_accumulate (x.begin(), x.size(), x.ownership().comm());
 
16643
  return y*dis_accumulate (x.begin_dof(), x.ndof(), x.ownership().comm());
6195
16644
}
6196
16645
template <class T, class M>
6197
16646
T
6198
16647
dot (const int& x, const field_indirect<T,M>& y)
6199
16648
{
6200
 
  return x*dis_accumulate (y.begin(), y.size(), y.ownership().comm());
 
16649
  return x*dis_accumulate (y.begin_dof(), y.ndof(), y.ownership().comm());
6201
16650
}
6202
16651
template <class T1, class T2, class M>
6203
16652
typename promote<T1,T2>::type
6204
16653
dot (const field_indirect<T1,M>& x, const T2& y)
6205
16654
{
6206
 
  return y*dis_accumulate (x.begin(), x.size(), x.ownership().comm());
 
16655
  return y*dis_accumulate (x.begin_dof(), x.ndof(), x.ownership().comm());
6207
16656
}
6208
16657
template <class T1, class T2, class M>
6209
16658
typename promote<T1,T2>::type
6210
16659
dot (const T1& x, const field_indirect<T2,M>& y)
6211
16660
{
6212
 
  return x*dis_accumulate (y.begin(), y.size(), y.ownership().comm());
 
16661
  return x*dis_accumulate (y.begin_dof(), y.ndof(), y.ownership().comm());
6213
16662
}
6214
16663
template <class T, class M>
6215
16664
T
6216
16665
dot (const field_indirect_const<T,M>& x, const int& y)
6217
16666
{
6218
 
  return y*dis_accumulate (x.begin(), x.size(), x.ownership().comm());
 
16667
  return y*dis_accumulate (x.begin_dof(), x.ndof(), x.ownership().comm());
6219
16668
}
6220
16669
template <class T, class M>
6221
16670
T
6222
16671
dot (const int& x, const field_indirect_const<T,M>& y)
6223
16672
{
6224
 
  return x*dis_accumulate (y.begin(), y.size(), y.ownership().comm());
 
16673
  return x*dis_accumulate (y.begin_dof(), y.ndof(), y.ownership().comm());
6225
16674
}
6226
16675
template <class T1, class T2, class M>
6227
16676
typename promote<T1,T2>::type
6228
16677
dot (const field_indirect_const<T1,M>& x, const T2& y)
6229
16678
{
6230
 
  return y*dis_accumulate (x.begin(), x.size(), x.ownership().comm());
 
16679
  return y*dis_accumulate (x.begin_dof(), x.ndof(), x.ownership().comm());
6231
16680
}
6232
16681
template <class T1, class T2, class M>
6233
16682
typename promote<T1,T2>::type
6234
16683
dot (const T1& x, const field_indirect_const<T2,M>& y)
6235
16684
{
6236
 
  return x*dis_accumulate (y.begin(), y.size(), y.ownership().comm());
 
16685
  return x*dis_accumulate (y.begin_dof(), y.ndof(), y.ownership().comm());
 
16686
}
 
16687
template <class T, class M>
 
16688
T
 
16689
dot (const field_component<T,M>& x, const int& y)
 
16690
{
 
16691
  return y*dis_accumulate (x.begin_dof(), x.ndof(), x.ownership().comm());
 
16692
}
 
16693
template <class T, class M>
 
16694
T
 
16695
dot (const int& x, const field_component<T,M>& y)
 
16696
{
 
16697
  return x*dis_accumulate (y.begin_dof(), y.ndof(), y.ownership().comm());
 
16698
}
 
16699
template <class T1, class T2, class M>
 
16700
typename promote<T1,T2>::type
 
16701
dot (const field_component<T1,M>& x, const T2& y)
 
16702
{
 
16703
  return y*dis_accumulate (x.begin_dof(), x.ndof(), x.ownership().comm());
 
16704
}
 
16705
template <class T1, class T2, class M>
 
16706
typename promote<T1,T2>::type
 
16707
dot (const T1& x, const field_component<T2,M>& y)
 
16708
{
 
16709
  return x*dis_accumulate (y.begin_dof(), y.ndof(), y.ownership().comm());
 
16710
}
 
16711
template <class T, class M>
 
16712
T
 
16713
dot (const field_component_const<T,M>& x, const int& y)
 
16714
{
 
16715
  return y*dis_accumulate (x.begin_dof(), x.ndof(), x.ownership().comm());
 
16716
}
 
16717
template <class T, class M>
 
16718
T
 
16719
dot (const int& x, const field_component_const<T,M>& y)
 
16720
{
 
16721
  return x*dis_accumulate (y.begin_dof(), y.ndof(), y.ownership().comm());
 
16722
}
 
16723
template <class T1, class T2, class M>
 
16724
typename promote<T1,T2>::type
 
16725
dot (const field_component_const<T1,M>& x, const T2& y)
 
16726
{
 
16727
  return y*dis_accumulate (x.begin_dof(), x.ndof(), x.ownership().comm());
 
16728
}
 
16729
template <class T1, class T2, class M>
 
16730
typename promote<T1,T2>::type
 
16731
dot (const T1& x, const field_component_const<T2,M>& y)
 
16732
{
 
16733
  return x*dis_accumulate (y.begin_dof(), y.ndof(), y.ownership().comm());
6237
16734
}
6238
16735
template <class T1, class T2, class M>
6239
16736
typename promote<T1,T2>::type
6240
16737
dot (const field_basic<T1,M>& x, const field_basic<T2,M>& y)
6241
16738
{
6242
 
  return dis_inner_product (x.begin(), y.begin(), x.size(), x.ownership().comm());
 
16739
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
6243
16740
}
6244
16741
template <class T1, class T2, class M>
6245
16742
typename promote<T1,T2>::type
6246
16743
dot (const field_basic<T1,M>& x, const field_indirect<T2,M>& y)
6247
16744
{
6248
 
  return dis_inner_product (x.begin(), y.begin(), x.size(), x.ownership().comm());
 
16745
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
6249
16746
}
6250
16747
template <class T1, class T2, class M>
6251
16748
typename promote<T1,T2>::type
6252
16749
dot (const field_basic<T1,M>& x, const field_indirect_const<T2,M>& y)
6253
16750
{
6254
 
  return dis_inner_product (x.begin(), y.begin(), x.size(), x.ownership().comm());
 
16751
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
 
16752
}
 
16753
template <class T1, class T2, class M>
 
16754
typename promote<T1,T2>::type
 
16755
dot (const field_basic<T1,M>& x, const field_component<T2,M>& y)
 
16756
{
 
16757
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
 
16758
}
 
16759
template <class T1, class T2, class M>
 
16760
typename promote<T1,T2>::type
 
16761
dot (const field_basic<T1,M>& x, const field_component_const<T2,M>& y)
 
16762
{
 
16763
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
6255
16764
}
6256
16765
template <class T1, class T2, class M>
6257
16766
typename promote<T1,T2>::type
6258
16767
dot (const field_indirect<T1,M>& x, const field_basic<T2,M>& y)
6259
16768
{
6260
 
  return dis_inner_product (x.begin(), y.begin(), x.size(), x.ownership().comm());
 
16769
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
6261
16770
}
6262
16771
template <class T1, class T2, class M>
6263
16772
typename promote<T1,T2>::type
6264
16773
dot (const field_indirect<T1,M>& x, const field_indirect<T2,M>& y)
6265
16774
{
6266
 
  return dis_inner_product (x.begin(), y.begin(), x.size(), x.ownership().comm());
 
16775
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
6267
16776
}
6268
16777
template <class T1, class T2, class M>
6269
16778
typename promote<T1,T2>::type
6270
16779
dot (const field_indirect<T1,M>& x, const field_indirect_const<T2,M>& y)
6271
16780
{
6272
 
  return dis_inner_product (x.begin(), y.begin(), x.size(), x.ownership().comm());
 
16781
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
 
16782
}
 
16783
template <class T1, class T2, class M>
 
16784
typename promote<T1,T2>::type
 
16785
dot (const field_indirect<T1,M>& x, const field_component<T2,M>& y)
 
16786
{
 
16787
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
 
16788
}
 
16789
template <class T1, class T2, class M>
 
16790
typename promote<T1,T2>::type
 
16791
dot (const field_indirect<T1,M>& x, const field_component_const<T2,M>& y)
 
16792
{
 
16793
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
6273
16794
}
6274
16795
template <class T1, class T2, class M>
6275
16796
typename promote<T1,T2>::type
6276
16797
dot (const field_indirect_const<T1,M>& x, const field_basic<T2,M>& y)
6277
16798
{
6278
 
  return dis_inner_product (x.begin(), y.begin(), x.size(), x.ownership().comm());
 
16799
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
6279
16800
}
6280
16801
template <class T1, class T2, class M>
6281
16802
typename promote<T1,T2>::type
6282
16803
dot (const field_indirect_const<T1,M>& x, const field_indirect<T2,M>& y)
6283
16804
{
6284
 
  return dis_inner_product (x.begin(), y.begin(), x.size(), x.ownership().comm());
 
16805
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
6285
16806
}
6286
16807
template <class T1, class T2, class M>
6287
16808
typename promote<T1,T2>::type
6288
16809
dot (const field_indirect_const<T1,M>& x, const field_indirect_const<T2,M>& y)
6289
16810
{
6290
 
  return dis_inner_product (x.begin(), y.begin(), x.size(), x.ownership().comm());
 
16811
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
 
16812
}
 
16813
template <class T1, class T2, class M>
 
16814
typename promote<T1,T2>::type
 
16815
dot (const field_indirect_const<T1,M>& x, const field_component<T2,M>& y)
 
16816
{
 
16817
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
 
16818
}
 
16819
template <class T1, class T2, class M>
 
16820
typename promote<T1,T2>::type
 
16821
dot (const field_indirect_const<T1,M>& x, const field_component_const<T2,M>& y)
 
16822
{
 
16823
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
 
16824
}
 
16825
template <class T1, class T2, class M>
 
16826
typename promote<T1,T2>::type
 
16827
dot (const field_component<T1,M>& x, const field_basic<T2,M>& y)
 
16828
{
 
16829
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
 
16830
}
 
16831
template <class T1, class T2, class M>
 
16832
typename promote<T1,T2>::type
 
16833
dot (const field_component<T1,M>& x, const field_indirect<T2,M>& y)
 
16834
{
 
16835
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
 
16836
}
 
16837
template <class T1, class T2, class M>
 
16838
typename promote<T1,T2>::type
 
16839
dot (const field_component<T1,M>& x, const field_indirect_const<T2,M>& y)
 
16840
{
 
16841
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
 
16842
}
 
16843
template <class T1, class T2, class M>
 
16844
typename promote<T1,T2>::type
 
16845
dot (const field_component<T1,M>& x, const field_component<T2,M>& y)
 
16846
{
 
16847
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
 
16848
}
 
16849
template <class T1, class T2, class M>
 
16850
typename promote<T1,T2>::type
 
16851
dot (const field_component<T1,M>& x, const field_component_const<T2,M>& y)
 
16852
{
 
16853
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
 
16854
}
 
16855
template <class T1, class T2, class M>
 
16856
typename promote<T1,T2>::type
 
16857
dot (const field_component_const<T1,M>& x, const field_basic<T2,M>& y)
 
16858
{
 
16859
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
 
16860
}
 
16861
template <class T1, class T2, class M>
 
16862
typename promote<T1,T2>::type
 
16863
dot (const field_component_const<T1,M>& x, const field_indirect<T2,M>& y)
 
16864
{
 
16865
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
 
16866
}
 
16867
template <class T1, class T2, class M>
 
16868
typename promote<T1,T2>::type
 
16869
dot (const field_component_const<T1,M>& x, const field_indirect_const<T2,M>& y)
 
16870
{
 
16871
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
 
16872
}
 
16873
template <class T1, class T2, class M>
 
16874
typename promote<T1,T2>::type
 
16875
dot (const field_component_const<T1,M>& x, const field_component<T2,M>& y)
 
16876
{
 
16877
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
 
16878
}
 
16879
template <class T1, class T2, class M>
 
16880
typename promote<T1,T2>::type
 
16881
dot (const field_component_const<T1,M>& x, const field_component_const<T2,M>& y)
 
16882
{
 
16883
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
6291
16884
}
6292
16885
template <class Expr>
6293
 
typename field_expr<Expr>::element_type
 
16886
typename field_expr<Expr>::value_type
6294
16887
dot (const field_expr<Expr>& x, const int& y)
6295
16888
{
6296
 
  return y*dis_accumulate (x.begin(), x.size(), x.ownership().comm());
 
16889
  return y*dis_accumulate (x.begin_dof(), x.ndof(), x.ownership().comm());
6297
16890
}
6298
16891
template <class Expr>
6299
 
typename field_expr<Expr>::element_type
 
16892
typename field_expr<Expr>::value_type
6300
16893
dot (const int& x, const field_expr<Expr>& y)
6301
16894
{
6302
 
  return x*dis_accumulate (y.begin(), y.size(), y.ownership().comm());
 
16895
  return x*dis_accumulate (y.begin_dof(), y.ndof(), y.ownership().comm());
6303
16896
}
6304
16897
template <class T, class Expr>
6305
 
typename promote<T,typename field_expr<Expr>::element_type>::type
 
16898
typename promote<T,typename field_expr<Expr>::value_type>::type
6306
16899
dot (const field_expr<Expr>& x, const T& y)
6307
16900
{
6308
 
  return y*dis_accumulate (x.begin(), x.size(), x.ownership().comm());
 
16901
  return y*dis_accumulate (x.begin_dof(), x.ndof(), x.ownership().comm());
6309
16902
}
6310
16903
template <class T, class Expr>
6311
 
typename promote<T,typename field_expr<Expr>::element_type>::type
 
16904
typename promote<T,typename field_expr<Expr>::value_type>::type
6312
16905
dot (const T& x, const field_expr<Expr>& y)
6313
16906
{
6314
 
  return x*dis_accumulate (y.begin(), y.size(), y.ownership().comm());
 
16907
  return x*dis_accumulate (y.begin_dof(), y.ndof(), y.ownership().comm());
6315
16908
}
6316
16909
template <class T, class M, class Expr>
6317
 
typename promote<T,typename field_expr<Expr>::element_type>::type
 
16910
typename promote<T,typename field_expr<Expr>::value_type>::type
6318
16911
dot (const field_basic<T,M>& x, const field_expr<Expr>& y)
6319
16912
{
6320
 
  return dis_inner_product (x.begin(), y.begin(), x.size(), x.ownership().comm());
 
16913
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
6321
16914
}
6322
16915
template <class T, class M, class Expr>
6323
 
typename promote<T,typename field_expr<Expr>::element_type>::type
 
16916
typename promote<T,typename field_expr<Expr>::value_type>::type
6324
16917
dot (const field_expr<Expr>& x, const field_basic<T,M>& y)
6325
16918
{
6326
 
  return dis_inner_product (x.begin(), y.begin(), x.size(), x.ownership().comm());
 
16919
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
6327
16920
}
6328
16921
template <class T, class M, class Expr>
6329
 
typename promote<T,typename field_expr<Expr>::element_type>::type
 
16922
typename promote<T,typename field_expr<Expr>::value_type>::type
6330
16923
dot (const field_indirect<T,M>& x, const field_expr<Expr>& y)
6331
16924
{
6332
 
  return dis_inner_product (x.begin(), y.begin(), x.size(), x.ownership().comm());
 
16925
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
6333
16926
}
6334
16927
template <class T, class M, class Expr>
6335
 
typename promote<T,typename field_expr<Expr>::element_type>::type
 
16928
typename promote<T,typename field_expr<Expr>::value_type>::type
6336
16929
dot (const field_expr<Expr>& x, const field_indirect<T,M>& y)
6337
16930
{
6338
 
  return dis_inner_product (x.begin(), y.begin(), x.size(), x.ownership().comm());
 
16931
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
6339
16932
}
6340
16933
template <class T, class M, class Expr>
6341
 
typename promote<T,typename field_expr<Expr>::element_type>::type
 
16934
typename promote<T,typename field_expr<Expr>::value_type>::type
6342
16935
dot (const field_indirect_const<T,M>& x, const field_expr<Expr>& y)
6343
16936
{
6344
 
  return dis_inner_product (x.begin(), y.begin(), x.size(), x.ownership().comm());
 
16937
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
6345
16938
}
6346
16939
template <class T, class M, class Expr>
6347
 
typename promote<T,typename field_expr<Expr>::element_type>::type
 
16940
typename promote<T,typename field_expr<Expr>::value_type>::type
6348
16941
dot (const field_expr<Expr>& x, const field_indirect_const<T,M>& y)
6349
16942
{
6350
 
  return dis_inner_product (x.begin(), y.begin(), x.size(), x.ownership().comm());
 
16943
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
 
16944
}
 
16945
template <class T, class M, class Expr>
 
16946
typename promote<T,typename field_expr<Expr>::value_type>::type
 
16947
dot (const field_component<T,M>& x, const field_expr<Expr>& y)
 
16948
{
 
16949
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
 
16950
}
 
16951
template <class T, class M, class Expr>
 
16952
typename promote<T,typename field_expr<Expr>::value_type>::type
 
16953
dot (const field_expr<Expr>& x, const field_component<T,M>& y)
 
16954
{
 
16955
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
 
16956
}
 
16957
template <class T, class M, class Expr>
 
16958
typename promote<T,typename field_expr<Expr>::value_type>::type
 
16959
dot (const field_component_const<T,M>& x, const field_expr<Expr>& y)
 
16960
{
 
16961
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
 
16962
}
 
16963
template <class T, class M, class Expr>
 
16964
typename promote<T,typename field_expr<Expr>::value_type>::type
 
16965
dot (const field_expr<Expr>& x, const field_component_const<T,M>& y)
 
16966
{
 
16967
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
6351
16968
}
6352
16969
template <class Expr1, class Expr2>
6353
16970
typename promote<
6354
 
  typename field_expr<Expr1>::element_type,
6355
 
  typename field_expr<Expr2>::element_type
 
16971
  typename field_expr<Expr1>::value_type,
 
16972
  typename field_expr<Expr2>::value_type
6356
16973
>::type
6357
16974
dot (const field_expr<Expr1>& x, const field_expr<Expr2>& y)
6358
16975
{
6359
 
  return dis_inner_product (x.begin(), y.begin(), x.size(), x.ownership().comm());
 
16976
  return dis_inner_product (x.begin_dof(), y.begin_dof(), x.ndof(), x.ownership().comm());
6360
16977
}
6361
16978
} // namespace rheolef
6362
16979
#endif // _RHEOLEF_FIELD_EXPR_OPS_H